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 /* Common in other bcrypt implementations, but missing from VS2008. */ 40 #ifndef BCRYPT_SUCCESS 41 #define BCRYPT_SUCCESS(r) ((NTSTATUS)(r) == STATUS_SUCCESS) 42 #endif 43 44 /* 45 * Message digest functions for Windows platform. 46 */ 47 #if defined(ARCHIVE_CRYPTO_MD5_WIN) ||\ 48 defined(ARCHIVE_CRYPTO_SHA1_WIN) ||\ 49 defined(ARCHIVE_CRYPTO_SHA256_WIN) ||\ 50 defined(ARCHIVE_CRYPTO_SHA384_WIN) ||\ 51 defined(ARCHIVE_CRYPTO_SHA512_WIN) 52 53 /* 54 * Initialize a Message digest. 55 */ 56 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA 57 static int 58 win_crypto_init(Digest_CTX *ctx, const WCHAR *algo) 59 { 60 NTSTATUS status; 61 ctx->valid = 0; 62 63 status = BCryptOpenAlgorithmProvider(&ctx->hAlg, algo, NULL, 0); 64 if (!BCRYPT_SUCCESS(status)) 65 return (ARCHIVE_FAILED); 66 status = BCryptCreateHash(ctx->hAlg, &ctx->hHash, NULL, 0, NULL, 0, 0); 67 if (!BCRYPT_SUCCESS(status)) { 68 BCryptCloseAlgorithmProvider(ctx->hAlg, 0); 69 return (ARCHIVE_FAILED); 70 } 71 72 ctx->valid = 1; 73 return (ARCHIVE_OK); 74 } 75 #else 76 static int 77 win_crypto_init(Digest_CTX *ctx, DWORD prov, ALG_ID algId) 78 { 79 80 ctx->valid = 0; 81 if (!CryptAcquireContext(&ctx->cryptProv, NULL, NULL, 82 prov, CRYPT_VERIFYCONTEXT)) { 83 if (GetLastError() != (DWORD)NTE_BAD_KEYSET) 84 return (ARCHIVE_FAILED); 85 if (!CryptAcquireContext(&ctx->cryptProv, NULL, NULL, 86 prov, CRYPT_NEWKEYSET)) 87 return (ARCHIVE_FAILED); 88 } 89 90 if (!CryptCreateHash(ctx->cryptProv, algId, 0, 0, &ctx->hash)) { 91 CryptReleaseContext(ctx->cryptProv, 0); 92 return (ARCHIVE_FAILED); 93 } 94 95 ctx->valid = 1; 96 return (ARCHIVE_OK); 97 } 98 #endif 99 100 /* 101 * Update a Message digest. 102 */ 103 static int 104 win_crypto_Update(Digest_CTX *ctx, const unsigned char *buf, size_t len) 105 { 106 107 if (!ctx->valid) 108 return (ARCHIVE_FAILED); 109 110 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA 111 BCryptHashData(ctx->hHash, 112 (PUCHAR)(uintptr_t)buf, 113 (ULONG)len, 0); 114 #else 115 CryptHashData(ctx->hash, 116 (unsigned char *)(uintptr_t)buf, 117 (DWORD)len, 0); 118 #endif 119 return (ARCHIVE_OK); 120 } 121 122 static int 123 win_crypto_Final(unsigned char *buf, size_t bufsize, Digest_CTX *ctx) 124 { 125 #if !(defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA) 126 DWORD siglen = (DWORD)bufsize; 127 #endif 128 129 if (!ctx->valid) 130 return (ARCHIVE_FAILED); 131 132 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA 133 BCryptFinishHash(ctx->hHash, buf, (ULONG)bufsize, 0); 134 BCryptDestroyHash(ctx->hHash); 135 BCryptCloseAlgorithmProvider(ctx->hAlg, 0); 136 #else 137 CryptGetHashParam(ctx->hash, HP_HASHVAL, buf, &siglen, 0); 138 CryptDestroyHash(ctx->hash); 139 CryptReleaseContext(ctx->cryptProv, 0); 140 #endif 141 ctx->valid = 0; 142 return (ARCHIVE_OK); 143 } 144 145 #endif /* defined(ARCHIVE_CRYPTO_*_WIN) */ 146 147 148 /* MD5 implementations */ 149 #if defined(ARCHIVE_CRYPTO_MD5_LIBC) 150 151 static int 152 __archive_md5init(archive_md5_ctx *ctx) 153 { 154 MD5Init(ctx); 155 return (ARCHIVE_OK); 156 } 157 158 static int 159 __archive_md5update(archive_md5_ctx *ctx, const void *indata, 160 size_t insize) 161 { 162 MD5Update(ctx, indata, insize); 163 return (ARCHIVE_OK); 164 } 165 166 static int 167 __archive_md5final(archive_md5_ctx *ctx, void *md) 168 { 169 MD5Final(md, ctx); 170 return (ARCHIVE_OK); 171 } 172 173 #elif defined(ARCHIVE_CRYPTO_MD5_LIBMD) 174 175 static int 176 __archive_md5init(archive_md5_ctx *ctx) 177 { 178 MD5Init(ctx); 179 return (ARCHIVE_OK); 180 } 181 182 static int 183 __archive_md5update(archive_md5_ctx *ctx, const void *indata, 184 size_t insize) 185 { 186 MD5Update(ctx, indata, insize); 187 return (ARCHIVE_OK); 188 } 189 190 static int 191 __archive_md5final(archive_md5_ctx *ctx, void *md) 192 { 193 MD5Final(md, ctx); 194 return (ARCHIVE_OK); 195 } 196 197 #elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM) 198 199 static int 200 __archive_md5init(archive_md5_ctx *ctx) 201 { 202 CC_MD5_Init(ctx); 203 return (ARCHIVE_OK); 204 } 205 206 static int 207 __archive_md5update(archive_md5_ctx *ctx, const void *indata, 208 size_t insize) 209 { 210 CC_MD5_Update(ctx, indata, insize); 211 return (ARCHIVE_OK); 212 } 213 214 static int 215 __archive_md5final(archive_md5_ctx *ctx, void *md) 216 { 217 CC_MD5_Final(md, ctx); 218 return (ARCHIVE_OK); 219 } 220 221 #elif defined(ARCHIVE_CRYPTO_MD5_MBEDTLS) 222 223 static int 224 __archive_md5init(archive_md5_ctx *ctx) 225 { 226 mbedtls_md5_init(ctx); 227 if (mbedtls_md5_starts_ret(ctx) == 0) 228 return (ARCHIVE_OK); 229 else 230 return (ARCHIVE_FATAL); 231 } 232 233 static int 234 __archive_md5update(archive_md5_ctx *ctx, const void *indata, 235 size_t insize) 236 { 237 if (mbedtls_md5_update_ret(ctx, indata, insize) == 0) 238 return (ARCHIVE_OK); 239 else 240 return (ARCHIVE_FATAL); 241 } 242 243 static int 244 __archive_md5final(archive_md5_ctx *ctx, void *md) 245 { 246 if (mbedtls_md5_finish_ret(ctx, md) == 0) { 247 mbedtls_md5_free(ctx); 248 return (ARCHIVE_OK); 249 } else { 250 mbedtls_md5_free(ctx); 251 return (ARCHIVE_FATAL); 252 } 253 } 254 255 #elif defined(ARCHIVE_CRYPTO_MD5_NETTLE) 256 257 static int 258 __archive_md5init(archive_md5_ctx *ctx) 259 { 260 md5_init(ctx); 261 return (ARCHIVE_OK); 262 } 263 264 static int 265 __archive_md5update(archive_md5_ctx *ctx, const void *indata, 266 size_t insize) 267 { 268 md5_update(ctx, insize, indata); 269 return (ARCHIVE_OK); 270 } 271 272 static int 273 __archive_md5final(archive_md5_ctx *ctx, void *md) 274 { 275 md5_digest(ctx, MD5_DIGEST_SIZE, md); 276 return (ARCHIVE_OK); 277 } 278 279 #elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL) 280 281 static int 282 __archive_md5init(archive_md5_ctx *ctx) 283 { 284 if ((*ctx = EVP_MD_CTX_new()) == NULL) 285 return (ARCHIVE_FAILED); 286 if (!EVP_DigestInit(*ctx, EVP_md5())) 287 return (ARCHIVE_FAILED); 288 return (ARCHIVE_OK); 289 } 290 291 static int 292 __archive_md5update(archive_md5_ctx *ctx, const void *indata, 293 size_t insize) 294 { 295 EVP_DigestUpdate(*ctx, indata, insize); 296 return (ARCHIVE_OK); 297 } 298 299 static int 300 __archive_md5final(archive_md5_ctx *ctx, void *md) 301 { 302 /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so 303 * this is meant to cope with that. Real fix is probably to fix 304 * archive_write_set_format_xar.c 305 */ 306 if (*ctx) { 307 EVP_DigestFinal(*ctx, md, NULL); 308 EVP_MD_CTX_free(*ctx); 309 *ctx = NULL; 310 } 311 return (ARCHIVE_OK); 312 } 313 314 #elif defined(ARCHIVE_CRYPTO_MD5_WIN) 315 316 static int 317 __archive_md5init(archive_md5_ctx *ctx) 318 { 319 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA 320 return (win_crypto_init(ctx, BCRYPT_MD5_ALGORITHM)); 321 #else 322 return (win_crypto_init(ctx, PROV_RSA_FULL, CALG_MD5)); 323 #endif 324 } 325 326 static int 327 __archive_md5update(archive_md5_ctx *ctx, const void *indata, 328 size_t insize) 329 { 330 return (win_crypto_Update(ctx, indata, insize)); 331 } 332 333 static int 334 __archive_md5final(archive_md5_ctx *ctx, void *md) 335 { 336 return (win_crypto_Final(md, 16, ctx)); 337 } 338 339 #else 340 341 static int 342 __archive_md5init(archive_md5_ctx *ctx) 343 { 344 (void)ctx; /* UNUSED */ 345 return (ARCHIVE_FAILED); 346 } 347 348 static int 349 __archive_md5update(archive_md5_ctx *ctx, const void *indata, 350 size_t insize) 351 { 352 (void)ctx; /* UNUSED */ 353 (void)indata; /* UNUSED */ 354 (void)insize; /* UNUSED */ 355 return (ARCHIVE_FAILED); 356 } 357 358 static int 359 __archive_md5final(archive_md5_ctx *ctx, void *md) 360 { 361 (void)ctx; /* UNUSED */ 362 (void)md; /* UNUSED */ 363 return (ARCHIVE_FAILED); 364 } 365 366 #endif 367 368 /* RIPEMD160 implementations */ 369 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC) 370 371 static int 372 __archive_ripemd160init(archive_rmd160_ctx *ctx) 373 { 374 RMD160Init(ctx); 375 return (ARCHIVE_OK); 376 } 377 378 static int 379 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 380 size_t insize) 381 { 382 RMD160Update(ctx, indata, insize); 383 return (ARCHIVE_OK); 384 } 385 386 static int 387 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md) 388 { 389 RMD160Final(md, ctx); 390 return (ARCHIVE_OK); 391 } 392 393 #elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD) 394 395 static int 396 __archive_ripemd160init(archive_rmd160_ctx *ctx) 397 { 398 RIPEMD160_Init(ctx); 399 return (ARCHIVE_OK); 400 } 401 402 static int 403 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 404 size_t insize) 405 { 406 RIPEMD160_Update(ctx, indata, insize); 407 return (ARCHIVE_OK); 408 } 409 410 static int 411 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md) 412 { 413 RIPEMD160_Final(md, ctx); 414 return (ARCHIVE_OK); 415 } 416 417 #elif defined(ARCHIVE_CRYPTO_RMD160_MBEDTLS) 418 419 static int 420 __archive_ripemd160init(archive_rmd160_ctx *ctx) 421 { 422 mbedtls_ripemd160_init(ctx); 423 if (mbedtls_ripemd160_starts_ret(ctx) == 0) 424 return (ARCHIVE_OK); 425 else 426 return (ARCHIVE_FATAL); 427 } 428 429 static int 430 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 431 size_t insize) 432 { 433 if (mbedtls_ripemd160_update_ret(ctx, indata, insize) == 0) 434 return (ARCHIVE_OK); 435 else 436 return (ARCHIVE_FATAL); 437 } 438 439 static int 440 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md) 441 { 442 if (mbedtls_ripemd160_finish_ret(ctx, md) == 0) { 443 mbedtls_ripemd160_free(ctx); 444 return (ARCHIVE_OK); 445 } else { 446 mbedtls_ripemd160_free(ctx); 447 return (ARCHIVE_FATAL); 448 } 449 } 450 451 #elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE) 452 453 static int 454 __archive_ripemd160init(archive_rmd160_ctx *ctx) 455 { 456 ripemd160_init(ctx); 457 return (ARCHIVE_OK); 458 } 459 460 static int 461 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 462 size_t insize) 463 { 464 ripemd160_update(ctx, insize, indata); 465 return (ARCHIVE_OK); 466 } 467 468 static int 469 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md) 470 { 471 ripemd160_digest(ctx, RIPEMD160_DIGEST_SIZE, md); 472 return (ARCHIVE_OK); 473 } 474 475 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL) 476 477 static int 478 __archive_ripemd160init(archive_rmd160_ctx *ctx) 479 { 480 if ((*ctx = EVP_MD_CTX_new()) == NULL) 481 return (ARCHIVE_FAILED); 482 if (!EVP_DigestInit(*ctx, EVP_ripemd160())) 483 return (ARCHIVE_FAILED); 484 return (ARCHIVE_OK); 485 } 486 487 static int 488 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 489 size_t insize) 490 { 491 EVP_DigestUpdate(*ctx, indata, insize); 492 return (ARCHIVE_OK); 493 } 494 495 static int 496 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md) 497 { 498 if (*ctx) { 499 EVP_DigestFinal(*ctx, md, NULL); 500 EVP_MD_CTX_free(*ctx); 501 *ctx = NULL; 502 } 503 return (ARCHIVE_OK); 504 } 505 506 #else 507 508 static int 509 __archive_ripemd160init(archive_rmd160_ctx *ctx) 510 { 511 (void)ctx; /* UNUSED */ 512 return (ARCHIVE_FAILED); 513 } 514 515 static int 516 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata, 517 size_t insize) 518 { 519 (void)ctx; /* UNUSED */ 520 (void)indata; /* UNUSED */ 521 (void)insize; /* UNUSED */ 522 return (ARCHIVE_FAILED); 523 } 524 525 static int 526 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md) 527 { 528 (void)ctx; /* UNUSED */ 529 (void)md; /* UNUSED */ 530 return (ARCHIVE_FAILED); 531 } 532 533 #endif 534 535 /* SHA1 implementations */ 536 #if defined(ARCHIVE_CRYPTO_SHA1_LIBC) 537 538 static int 539 __archive_sha1init(archive_sha1_ctx *ctx) 540 { 541 SHA1Init(ctx); 542 return (ARCHIVE_OK); 543 } 544 545 static int 546 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata, 547 size_t insize) 548 { 549 SHA1Update(ctx, indata, insize); 550 return (ARCHIVE_OK); 551 } 552 553 static int 554 __archive_sha1final(archive_sha1_ctx *ctx, void *md) 555 { 556 SHA1Final(md, ctx); 557 return (ARCHIVE_OK); 558 } 559 560 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD) 561 562 static int 563 __archive_sha1init(archive_sha1_ctx *ctx) 564 { 565 SHA1_Init(ctx); 566 return (ARCHIVE_OK); 567 } 568 569 static int 570 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata, 571 size_t insize) 572 { 573 SHA1_Update(ctx, indata, insize); 574 return (ARCHIVE_OK); 575 } 576 577 static int 578 __archive_sha1final(archive_sha1_ctx *ctx, void *md) 579 { 580 SHA1_Final(md, ctx); 581 return (ARCHIVE_OK); 582 } 583 584 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM) 585 586 static int 587 __archive_sha1init(archive_sha1_ctx *ctx) 588 { 589 CC_SHA1_Init(ctx); 590 return (ARCHIVE_OK); 591 } 592 593 static int 594 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata, 595 size_t insize) 596 { 597 CC_SHA1_Update(ctx, indata, insize); 598 return (ARCHIVE_OK); 599 } 600 601 static int 602 __archive_sha1final(archive_sha1_ctx *ctx, void *md) 603 { 604 CC_SHA1_Final(md, ctx); 605 return (ARCHIVE_OK); 606 } 607 608 #elif defined(ARCHIVE_CRYPTO_SHA1_MBEDTLS) 609 610 static int 611 __archive_sha1init(archive_sha1_ctx *ctx) 612 { 613 mbedtls_sha1_init(ctx); 614 if (mbedtls_sha1_starts_ret(ctx) == 0) 615 return (ARCHIVE_OK); 616 else 617 return (ARCHIVE_FATAL); 618 } 619 620 static int 621 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata, 622 size_t insize) 623 { 624 if (mbedtls_sha1_update_ret(ctx, indata, insize) == 0) 625 return (ARCHIVE_OK); 626 else 627 return (ARCHIVE_FATAL); 628 } 629 630 static int 631 __archive_sha1final(archive_sha1_ctx *ctx, void *md) 632 { 633 if (mbedtls_sha1_finish_ret(ctx, md) == 0) { 634 mbedtls_sha1_free(ctx); 635 return (ARCHIVE_OK); 636 } else { 637 mbedtls_sha1_free(ctx); 638 return (ARCHIVE_FATAL); 639 } 640 } 641 642 #elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE) 643 644 static int 645 __archive_sha1init(archive_sha1_ctx *ctx) 646 { 647 sha1_init(ctx); 648 return (ARCHIVE_OK); 649 } 650 651 static int 652 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata, 653 size_t insize) 654 { 655 sha1_update(ctx, insize, indata); 656 return (ARCHIVE_OK); 657 } 658 659 static int 660 __archive_sha1final(archive_sha1_ctx *ctx, void *md) 661 { 662 sha1_digest(ctx, SHA1_DIGEST_SIZE, md); 663 return (ARCHIVE_OK); 664 } 665 666 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL) 667 668 static int 669 __archive_sha1init(archive_sha1_ctx *ctx) 670 { 671 if ((*ctx = EVP_MD_CTX_new()) == NULL) 672 return (ARCHIVE_FAILED); 673 if (!EVP_DigestInit(*ctx, EVP_sha1())) 674 return (ARCHIVE_FAILED); 675 return (ARCHIVE_OK); 676 } 677 678 static int 679 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata, 680 size_t insize) 681 { 682 EVP_DigestUpdate(*ctx, indata, insize); 683 return (ARCHIVE_OK); 684 } 685 686 static int 687 __archive_sha1final(archive_sha1_ctx *ctx, void *md) 688 { 689 /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so 690 * this is meant to cope with that. Real fix is probably to fix 691 * archive_write_set_format_xar.c 692 */ 693 if (*ctx) { 694 EVP_DigestFinal(*ctx, md, NULL); 695 EVP_MD_CTX_free(*ctx); 696 *ctx = NULL; 697 } 698 return (ARCHIVE_OK); 699 } 700 701 #elif defined(ARCHIVE_CRYPTO_SHA1_WIN) 702 703 static int 704 __archive_sha1init(archive_sha1_ctx *ctx) 705 { 706 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA 707 return (win_crypto_init(ctx, BCRYPT_SHA1_ALGORITHM)); 708 #else 709 return (win_crypto_init(ctx, PROV_RSA_FULL, CALG_SHA1)); 710 #endif 711 } 712 713 static int 714 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata, 715 size_t insize) 716 { 717 return (win_crypto_Update(ctx, indata, insize)); 718 } 719 720 static int 721 __archive_sha1final(archive_sha1_ctx *ctx, void *md) 722 { 723 return (win_crypto_Final(md, 20, ctx)); 724 } 725 726 #else 727 728 static int 729 __archive_sha1init(archive_sha1_ctx *ctx) 730 { 731 (void)ctx; /* UNUSED */ 732 return (ARCHIVE_FAILED); 733 } 734 735 static int 736 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata, 737 size_t insize) 738 { 739 (void)ctx; /* UNUSED */ 740 (void)indata; /* UNUSED */ 741 (void)insize; /* UNUSED */ 742 return (ARCHIVE_FAILED); 743 } 744 745 static int 746 __archive_sha1final(archive_sha1_ctx *ctx, void *md) 747 { 748 (void)ctx; /* UNUSED */ 749 (void)md; /* UNUSED */ 750 return (ARCHIVE_FAILED); 751 } 752 753 #endif 754 755 /* SHA256 implementations */ 756 #if defined(ARCHIVE_CRYPTO_SHA256_LIBC) 757 758 static int 759 __archive_sha256init(archive_sha256_ctx *ctx) 760 { 761 SHA256_Init(ctx); 762 return (ARCHIVE_OK); 763 } 764 765 static int 766 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata, 767 size_t insize) 768 { 769 SHA256_Update(ctx, indata, insize); 770 return (ARCHIVE_OK); 771 } 772 773 static int 774 __archive_sha256final(archive_sha256_ctx *ctx, void *md) 775 { 776 SHA256_Final(md, ctx); 777 return (ARCHIVE_OK); 778 } 779 780 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2) 781 782 static int 783 __archive_sha256init(archive_sha256_ctx *ctx) 784 { 785 SHA256Init(ctx); 786 return (ARCHIVE_OK); 787 } 788 789 static int 790 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata, 791 size_t insize) 792 { 793 SHA256Update(ctx, indata, insize); 794 return (ARCHIVE_OK); 795 } 796 797 static int 798 __archive_sha256final(archive_sha256_ctx *ctx, void *md) 799 { 800 SHA256Final(md, ctx); 801 return (ARCHIVE_OK); 802 } 803 804 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3) 805 806 static int 807 __archive_sha256init(archive_sha256_ctx *ctx) 808 { 809 SHA256Init(ctx); 810 return (ARCHIVE_OK); 811 } 812 813 static int 814 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata, 815 size_t insize) 816 { 817 SHA256Update(ctx, indata, insize); 818 return (ARCHIVE_OK); 819 } 820 821 static int 822 __archive_sha256final(archive_sha256_ctx *ctx, void *md) 823 { 824 SHA256Final(md, ctx); 825 return (ARCHIVE_OK); 826 } 827 828 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD) 829 830 static int 831 __archive_sha256init(archive_sha256_ctx *ctx) 832 { 833 SHA256_Init(ctx); 834 return (ARCHIVE_OK); 835 } 836 837 static int 838 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata, 839 size_t insize) 840 { 841 SHA256_Update(ctx, indata, insize); 842 return (ARCHIVE_OK); 843 } 844 845 static int 846 __archive_sha256final(archive_sha256_ctx *ctx, void *md) 847 { 848 SHA256_Final(md, ctx); 849 return (ARCHIVE_OK); 850 } 851 852 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM) 853 854 static int 855 __archive_sha256init(archive_sha256_ctx *ctx) 856 { 857 CC_SHA256_Init(ctx); 858 return (ARCHIVE_OK); 859 } 860 861 static int 862 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata, 863 size_t insize) 864 { 865 CC_SHA256_Update(ctx, indata, insize); 866 return (ARCHIVE_OK); 867 } 868 869 static int 870 __archive_sha256final(archive_sha256_ctx *ctx, void *md) 871 { 872 CC_SHA256_Final(md, ctx); 873 return (ARCHIVE_OK); 874 } 875 876 #elif defined(ARCHIVE_CRYPTO_SHA256_MBEDTLS) 877 878 static int 879 __archive_sha256init(archive_sha256_ctx *ctx) 880 { 881 mbedtls_sha256_init(ctx); 882 if (mbedtls_sha256_starts_ret(ctx, 0) == 0) 883 return (ARCHIVE_OK); 884 else 885 return (ARCHIVE_FATAL); 886 } 887 888 static int 889 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata, 890 size_t insize) 891 { 892 if (mbedtls_sha256_update_ret(ctx, indata, insize) == 0) 893 return (ARCHIVE_OK); 894 else 895 return (ARCHIVE_FATAL); 896 } 897 898 static int 899 __archive_sha256final(archive_sha256_ctx *ctx, void *md) 900 { 901 if (mbedtls_sha256_finish_ret(ctx, md) == 0) { 902 mbedtls_sha256_free(ctx); 903 return (ARCHIVE_OK); 904 } else { 905 mbedtls_sha256_free(ctx); 906 return (ARCHIVE_FATAL); 907 } 908 } 909 910 #elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE) 911 912 static int 913 __archive_sha256init(archive_sha256_ctx *ctx) 914 { 915 sha256_init(ctx); 916 return (ARCHIVE_OK); 917 } 918 919 static int 920 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata, 921 size_t insize) 922 { 923 sha256_update(ctx, insize, indata); 924 return (ARCHIVE_OK); 925 } 926 927 static int 928 __archive_sha256final(archive_sha256_ctx *ctx, void *md) 929 { 930 sha256_digest(ctx, SHA256_DIGEST_SIZE, md); 931 return (ARCHIVE_OK); 932 } 933 934 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL) 935 936 static int 937 __archive_sha256init(archive_sha256_ctx *ctx) 938 { 939 if ((*ctx = EVP_MD_CTX_new()) == NULL) 940 return (ARCHIVE_FAILED); 941 if (!EVP_DigestInit(*ctx, EVP_sha256())) 942 return (ARCHIVE_FAILED); 943 return (ARCHIVE_OK); 944 } 945 946 static int 947 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata, 948 size_t insize) 949 { 950 EVP_DigestUpdate(*ctx, indata, insize); 951 return (ARCHIVE_OK); 952 } 953 954 static int 955 __archive_sha256final(archive_sha256_ctx *ctx, void *md) 956 { 957 if (*ctx) { 958 EVP_DigestFinal(*ctx, md, NULL); 959 EVP_MD_CTX_free(*ctx); 960 *ctx = NULL; 961 } 962 return (ARCHIVE_OK); 963 } 964 965 #elif defined(ARCHIVE_CRYPTO_SHA256_WIN) 966 967 static int 968 __archive_sha256init(archive_sha256_ctx *ctx) 969 { 970 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA 971 return (win_crypto_init(ctx, BCRYPT_SHA256_ALGORITHM)); 972 #else 973 return (win_crypto_init(ctx, PROV_RSA_AES, CALG_SHA_256)); 974 #endif 975 } 976 977 static int 978 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata, 979 size_t insize) 980 { 981 return (win_crypto_Update(ctx, indata, insize)); 982 } 983 984 static int 985 __archive_sha256final(archive_sha256_ctx *ctx, void *md) 986 { 987 return (win_crypto_Final(md, 32, ctx)); 988 } 989 990 #else 991 992 static int 993 __archive_sha256init(archive_sha256_ctx *ctx) 994 { 995 (void)ctx; /* UNUSED */ 996 return (ARCHIVE_FAILED); 997 } 998 999 static int 1000 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata, 1001 size_t insize) 1002 { 1003 (void)ctx; /* UNUSED */ 1004 (void)indata; /* UNUSED */ 1005 (void)insize; /* UNUSED */ 1006 return (ARCHIVE_FAILED); 1007 } 1008 1009 static int 1010 __archive_sha256final(archive_sha256_ctx *ctx, void *md) 1011 { 1012 (void)ctx; /* UNUSED */ 1013 (void)md; /* UNUSED */ 1014 return (ARCHIVE_FAILED); 1015 } 1016 1017 #endif 1018 1019 /* SHA384 implementations */ 1020 #if defined(ARCHIVE_CRYPTO_SHA384_LIBC) 1021 1022 static int 1023 __archive_sha384init(archive_sha384_ctx *ctx) 1024 { 1025 SHA384_Init(ctx); 1026 return (ARCHIVE_OK); 1027 } 1028 1029 static int 1030 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata, 1031 size_t insize) 1032 { 1033 SHA384_Update(ctx, indata, insize); 1034 return (ARCHIVE_OK); 1035 } 1036 1037 static int 1038 __archive_sha384final(archive_sha384_ctx *ctx, void *md) 1039 { 1040 SHA384_Final(md, ctx); 1041 return (ARCHIVE_OK); 1042 } 1043 1044 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2) 1045 1046 static int 1047 __archive_sha384init(archive_sha384_ctx *ctx) 1048 { 1049 SHA384Init(ctx); 1050 return (ARCHIVE_OK); 1051 } 1052 1053 static int 1054 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata, 1055 size_t insize) 1056 { 1057 SHA384Update(ctx, indata, insize); 1058 return (ARCHIVE_OK); 1059 } 1060 1061 static int 1062 __archive_sha384final(archive_sha384_ctx *ctx, void *md) 1063 { 1064 SHA384Final(md, ctx); 1065 return (ARCHIVE_OK); 1066 } 1067 1068 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3) 1069 1070 static int 1071 __archive_sha384init(archive_sha384_ctx *ctx) 1072 { 1073 SHA384Init(ctx); 1074 return (ARCHIVE_OK); 1075 } 1076 1077 static int 1078 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata, 1079 size_t insize) 1080 { 1081 SHA384Update(ctx, indata, insize); 1082 return (ARCHIVE_OK); 1083 } 1084 1085 static int 1086 __archive_sha384final(archive_sha384_ctx *ctx, void *md) 1087 { 1088 SHA384Final(md, ctx); 1089 return (ARCHIVE_OK); 1090 } 1091 1092 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM) 1093 1094 static int 1095 __archive_sha384init(archive_sha384_ctx *ctx) 1096 { 1097 CC_SHA384_Init(ctx); 1098 return (ARCHIVE_OK); 1099 } 1100 1101 static int 1102 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata, 1103 size_t insize) 1104 { 1105 CC_SHA384_Update(ctx, indata, insize); 1106 return (ARCHIVE_OK); 1107 } 1108 1109 static int 1110 __archive_sha384final(archive_sha384_ctx *ctx, void *md) 1111 { 1112 CC_SHA384_Final(md, ctx); 1113 return (ARCHIVE_OK); 1114 } 1115 1116 #elif defined(ARCHIVE_CRYPTO_SHA384_MBEDTLS) 1117 1118 static int 1119 __archive_sha384init(archive_sha384_ctx *ctx) 1120 { 1121 mbedtls_sha512_init(ctx); 1122 if (mbedtls_sha512_starts_ret(ctx, 1) == 0) 1123 return (ARCHIVE_OK); 1124 else 1125 return (ARCHIVE_FATAL); 1126 } 1127 1128 static int 1129 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata, 1130 size_t insize) 1131 { 1132 if (mbedtls_sha512_update_ret(ctx, indata, insize) == 0) 1133 return (ARCHIVE_OK); 1134 else 1135 return (ARCHIVE_FATAL); 1136 } 1137 1138 static int 1139 __archive_sha384final(archive_sha384_ctx *ctx, void *md) 1140 { 1141 if (mbedtls_sha512_finish_ret(ctx, md) == 0) { 1142 mbedtls_sha512_free(ctx); 1143 return (ARCHIVE_OK); 1144 } else { 1145 mbedtls_sha512_free(ctx); 1146 return (ARCHIVE_FATAL); 1147 } 1148 } 1149 1150 #elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE) 1151 1152 static int 1153 __archive_sha384init(archive_sha384_ctx *ctx) 1154 { 1155 sha384_init(ctx); 1156 return (ARCHIVE_OK); 1157 } 1158 1159 static int 1160 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata, 1161 size_t insize) 1162 { 1163 sha384_update(ctx, insize, indata); 1164 return (ARCHIVE_OK); 1165 } 1166 1167 static int 1168 __archive_sha384final(archive_sha384_ctx *ctx, void *md) 1169 { 1170 sha384_digest(ctx, SHA384_DIGEST_SIZE, md); 1171 return (ARCHIVE_OK); 1172 } 1173 1174 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL) 1175 1176 static int 1177 __archive_sha384init(archive_sha384_ctx *ctx) 1178 { 1179 if ((*ctx = EVP_MD_CTX_new()) == NULL) 1180 return (ARCHIVE_FAILED); 1181 if (!EVP_DigestInit(*ctx, EVP_sha384())) 1182 return (ARCHIVE_FAILED); 1183 return (ARCHIVE_OK); 1184 } 1185 1186 static int 1187 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata, 1188 size_t insize) 1189 { 1190 EVP_DigestUpdate(*ctx, indata, insize); 1191 return (ARCHIVE_OK); 1192 } 1193 1194 static int 1195 __archive_sha384final(archive_sha384_ctx *ctx, void *md) 1196 { 1197 if (*ctx) { 1198 EVP_DigestFinal(*ctx, md, NULL); 1199 EVP_MD_CTX_free(*ctx); 1200 *ctx = NULL; 1201 } 1202 return (ARCHIVE_OK); 1203 } 1204 1205 #elif defined(ARCHIVE_CRYPTO_SHA384_WIN) 1206 1207 static int 1208 __archive_sha384init(archive_sha384_ctx *ctx) 1209 { 1210 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA 1211 return (win_crypto_init(ctx, BCRYPT_SHA384_ALGORITHM)); 1212 #else 1213 return (win_crypto_init(ctx, PROV_RSA_AES, CALG_SHA_384)); 1214 #endif 1215 } 1216 1217 static int 1218 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata, 1219 size_t insize) 1220 { 1221 return (win_crypto_Update(ctx, indata, insize)); 1222 } 1223 1224 static int 1225 __archive_sha384final(archive_sha384_ctx *ctx, void *md) 1226 { 1227 return (win_crypto_Final(md, 48, ctx)); 1228 } 1229 1230 #else 1231 1232 static int 1233 __archive_sha384init(archive_sha384_ctx *ctx) 1234 { 1235 (void)ctx; /* UNUSED */ 1236 return (ARCHIVE_FAILED); 1237 } 1238 1239 static int 1240 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata, 1241 size_t insize) 1242 { 1243 (void)ctx; /* UNUSED */ 1244 (void)indata; /* UNUSED */ 1245 (void)insize; /* UNUSED */ 1246 return (ARCHIVE_FAILED); 1247 } 1248 1249 static int 1250 __archive_sha384final(archive_sha384_ctx *ctx, void *md) 1251 { 1252 (void)ctx; /* UNUSED */ 1253 (void)md; /* UNUSED */ 1254 return (ARCHIVE_FAILED); 1255 } 1256 1257 #endif 1258 1259 /* SHA512 implementations */ 1260 #if defined(ARCHIVE_CRYPTO_SHA512_LIBC) 1261 1262 static int 1263 __archive_sha512init(archive_sha512_ctx *ctx) 1264 { 1265 SHA512_Init(ctx); 1266 return (ARCHIVE_OK); 1267 } 1268 1269 static int 1270 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata, 1271 size_t insize) 1272 { 1273 SHA512_Update(ctx, indata, insize); 1274 return (ARCHIVE_OK); 1275 } 1276 1277 static int 1278 __archive_sha512final(archive_sha512_ctx *ctx, void *md) 1279 { 1280 SHA512_Final(md, ctx); 1281 return (ARCHIVE_OK); 1282 } 1283 1284 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2) 1285 1286 static int 1287 __archive_sha512init(archive_sha512_ctx *ctx) 1288 { 1289 SHA512Init(ctx); 1290 return (ARCHIVE_OK); 1291 } 1292 1293 static int 1294 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata, 1295 size_t insize) 1296 { 1297 SHA512Update(ctx, indata, insize); 1298 return (ARCHIVE_OK); 1299 } 1300 1301 static int 1302 __archive_sha512final(archive_sha512_ctx *ctx, void *md) 1303 { 1304 SHA512Final(md, ctx); 1305 return (ARCHIVE_OK); 1306 } 1307 1308 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3) 1309 1310 static int 1311 __archive_sha512init(archive_sha512_ctx *ctx) 1312 { 1313 SHA512Init(ctx); 1314 return (ARCHIVE_OK); 1315 } 1316 1317 static int 1318 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata, 1319 size_t insize) 1320 { 1321 SHA512Update(ctx, indata, insize); 1322 return (ARCHIVE_OK); 1323 } 1324 1325 static int 1326 __archive_sha512final(archive_sha512_ctx *ctx, void *md) 1327 { 1328 SHA512Final(md, ctx); 1329 return (ARCHIVE_OK); 1330 } 1331 1332 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD) 1333 1334 static int 1335 __archive_sha512init(archive_sha512_ctx *ctx) 1336 { 1337 SHA512_Init(ctx); 1338 return (ARCHIVE_OK); 1339 } 1340 1341 static int 1342 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata, 1343 size_t insize) 1344 { 1345 SHA512_Update(ctx, indata, insize); 1346 return (ARCHIVE_OK); 1347 } 1348 1349 static int 1350 __archive_sha512final(archive_sha512_ctx *ctx, void *md) 1351 { 1352 SHA512_Final(md, ctx); 1353 return (ARCHIVE_OK); 1354 } 1355 1356 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM) 1357 1358 static int 1359 __archive_sha512init(archive_sha512_ctx *ctx) 1360 { 1361 CC_SHA512_Init(ctx); 1362 return (ARCHIVE_OK); 1363 } 1364 1365 static int 1366 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata, 1367 size_t insize) 1368 { 1369 CC_SHA512_Update(ctx, indata, insize); 1370 return (ARCHIVE_OK); 1371 } 1372 1373 static int 1374 __archive_sha512final(archive_sha512_ctx *ctx, void *md) 1375 { 1376 CC_SHA512_Final(md, ctx); 1377 return (ARCHIVE_OK); 1378 } 1379 1380 #elif defined(ARCHIVE_CRYPTO_SHA512_MBEDTLS) 1381 1382 static int 1383 __archive_sha512init(archive_sha512_ctx *ctx) 1384 { 1385 mbedtls_sha512_init(ctx); 1386 if (mbedtls_sha512_starts_ret(ctx, 0) == 0) 1387 return (ARCHIVE_OK); 1388 else 1389 return (ARCHIVE_FATAL); 1390 } 1391 1392 static int 1393 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata, 1394 size_t insize) 1395 { 1396 if (mbedtls_sha512_update_ret(ctx, indata, insize) == 0) 1397 return (ARCHIVE_OK); 1398 else 1399 return (ARCHIVE_FATAL); 1400 } 1401 1402 static int 1403 __archive_sha512final(archive_sha512_ctx *ctx, void *md) 1404 { 1405 if (mbedtls_sha512_finish_ret(ctx, md) == 0) { 1406 mbedtls_sha512_free(ctx); 1407 return (ARCHIVE_OK); 1408 } else { 1409 mbedtls_sha512_free(ctx); 1410 return (ARCHIVE_FATAL); 1411 } 1412 } 1413 1414 #elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE) 1415 1416 static int 1417 __archive_sha512init(archive_sha512_ctx *ctx) 1418 { 1419 sha512_init(ctx); 1420 return (ARCHIVE_OK); 1421 } 1422 1423 static int 1424 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata, 1425 size_t insize) 1426 { 1427 sha512_update(ctx, insize, indata); 1428 return (ARCHIVE_OK); 1429 } 1430 1431 static int 1432 __archive_sha512final(archive_sha512_ctx *ctx, void *md) 1433 { 1434 sha512_digest(ctx, SHA512_DIGEST_SIZE, md); 1435 return (ARCHIVE_OK); 1436 } 1437 1438 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL) 1439 1440 static int 1441 __archive_sha512init(archive_sha512_ctx *ctx) 1442 { 1443 if ((*ctx = EVP_MD_CTX_new()) == NULL) 1444 return (ARCHIVE_FAILED); 1445 if (!EVP_DigestInit(*ctx, EVP_sha512())) 1446 return (ARCHIVE_FAILED); 1447 return (ARCHIVE_OK); 1448 } 1449 1450 static int 1451 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata, 1452 size_t insize) 1453 { 1454 EVP_DigestUpdate(*ctx, indata, insize); 1455 return (ARCHIVE_OK); 1456 } 1457 1458 static int 1459 __archive_sha512final(archive_sha512_ctx *ctx, void *md) 1460 { 1461 if (*ctx) { 1462 EVP_DigestFinal(*ctx, md, NULL); 1463 EVP_MD_CTX_free(*ctx); 1464 *ctx = NULL; 1465 } 1466 return (ARCHIVE_OK); 1467 } 1468 1469 #elif defined(ARCHIVE_CRYPTO_SHA512_WIN) 1470 1471 static int 1472 __archive_sha512init(archive_sha512_ctx *ctx) 1473 { 1474 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA 1475 return (win_crypto_init(ctx, BCRYPT_SHA512_ALGORITHM)); 1476 #else 1477 return (win_crypto_init(ctx, PROV_RSA_AES, CALG_SHA_512)); 1478 #endif 1479 } 1480 1481 static int 1482 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata, 1483 size_t insize) 1484 { 1485 return (win_crypto_Update(ctx, indata, insize)); 1486 } 1487 1488 static int 1489 __archive_sha512final(archive_sha512_ctx *ctx, void *md) 1490 { 1491 return (win_crypto_Final(md, 64, ctx)); 1492 } 1493 1494 #else 1495 1496 static int 1497 __archive_sha512init(archive_sha512_ctx *ctx) 1498 { 1499 (void)ctx; /* UNUSED */ 1500 return (ARCHIVE_FAILED); 1501 } 1502 1503 static int 1504 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata, 1505 size_t insize) 1506 { 1507 (void)ctx; /* UNUSED */ 1508 (void)indata; /* UNUSED */ 1509 (void)insize; /* UNUSED */ 1510 return (ARCHIVE_FAILED); 1511 } 1512 1513 static int 1514 __archive_sha512final(archive_sha512_ctx *ctx, void *md) 1515 { 1516 (void)ctx; /* UNUSED */ 1517 (void)md; /* UNUSED */ 1518 return (ARCHIVE_FAILED); 1519 } 1520 1521 #endif 1522 1523 /* NOTE: Message Digest functions are set based on availability and by the 1524 * following order of preference. 1525 * 1. libc 1526 * 2. libc2 1527 * 3. libc3 1528 * 4. libSystem 1529 * 5. Nettle 1530 * 6. OpenSSL 1531 * 7. libmd 1532 * 8. Windows API 1533 */ 1534 const struct archive_digest __archive_digest = 1535 { 1536 /* MD5 */ 1537 &__archive_md5init, 1538 &__archive_md5update, 1539 &__archive_md5final, 1540 1541 /* RIPEMD160 */ 1542 &__archive_ripemd160init, 1543 &__archive_ripemd160update, 1544 &__archive_ripemd160final, 1545 1546 /* SHA1 */ 1547 &__archive_sha1init, 1548 &__archive_sha1update, 1549 &__archive_sha1final, 1550 1551 /* SHA256 */ 1552 &__archive_sha256init, 1553 &__archive_sha256update, 1554 &__archive_sha256final, 1555 1556 /* SHA384 */ 1557 &__archive_sha384init, 1558 &__archive_sha384update, 1559 &__archive_sha384final, 1560 1561 /* SHA512 */ 1562 &__archive_sha512init, 1563 &__archive_sha512update, 1564 &__archive_sha512final 1565 }; 1566