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