archive_digest.c revision 362133
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 */ 51static int 52win_crypto_init(Digest_CTX *ctx, ALG_ID algId) 53{ 54 55 ctx->valid = 0; 56 if (!CryptAcquireContext(&ctx->cryptProv, NULL, NULL, 57 PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) { 58 if (GetLastError() != (DWORD)NTE_BAD_KEYSET) 59 return (ARCHIVE_FAILED); 60 if (!CryptAcquireContext(&ctx->cryptProv, NULL, NULL, 61 PROV_RSA_FULL, CRYPT_NEWKEYSET)) 62 return (ARCHIVE_FAILED); 63 } 64 65 if (!CryptCreateHash(ctx->cryptProv, algId, 0, 0, &ctx->hash)) { 66 CryptReleaseContext(ctx->cryptProv, 0); 67 return (ARCHIVE_FAILED); 68 } 69 70 ctx->valid = 1; 71 return (ARCHIVE_OK); 72} 73 74/* 75 * Update a Message digest. 76 */ 77static int 78win_crypto_Update(Digest_CTX *ctx, const unsigned char *buf, size_t len) 79{ 80 81 if (!ctx->valid) 82 return (ARCHIVE_FAILED); 83 84 CryptHashData(ctx->hash, 85 (unsigned char *)(uintptr_t)buf, 86 (DWORD)len, 0); 87 return (ARCHIVE_OK); 88} 89 90static int 91win_crypto_Final(unsigned char *buf, size_t bufsize, Digest_CTX *ctx) 92{ 93 DWORD siglen = (DWORD)bufsize; 94 95 if (!ctx->valid) 96 return (ARCHIVE_FAILED); 97 98 CryptGetHashParam(ctx->hash, HP_HASHVAL, buf, &siglen, 0); 99 CryptDestroyHash(ctx->hash); 100 CryptReleaseContext(ctx->cryptProv, 0); 101 ctx->valid = 0; 102 return (ARCHIVE_OK); 103} 104 105#endif /* defined(ARCHIVE_CRYPTO_*_WIN) */ 106 107 108/* MD5 implementations */ 109#if defined(ARCHIVE_CRYPTO_MD5_LIBC) 110 111static int 112__archive_md5init(archive_md5_ctx *ctx) 113{ 114 MD5Init(ctx); 115 return (ARCHIVE_OK); 116} 117 118static 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 126static 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 135static int 136__archive_md5init(archive_md5_ctx *ctx) 137{ 138 MD5Init(ctx); 139 return (ARCHIVE_OK); 140} 141 142static 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 150static 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 159static int 160__archive_md5init(archive_md5_ctx *ctx) 161{ 162 CC_MD5_Init(ctx); 163 return (ARCHIVE_OK); 164} 165 166static 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 174static 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 183static 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 193static 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 203static 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 217static int 218__archive_md5init(archive_md5_ctx *ctx) 219{ 220 md5_init(ctx); 221 return (ARCHIVE_OK); 222} 223 224static 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 232static 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 241static 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 250static 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 258static 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 275static int 276__archive_md5init(archive_md5_ctx *ctx) 277{ 278 return (win_crypto_init(ctx, CALG_MD5)); 279} 280 281static 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 288static int 289__archive_md5final(archive_md5_ctx *ctx, void *md) 290{ 291 return (win_crypto_Final(md, 16, ctx)); 292} 293 294#else 295 296static int 297__archive_md5init(archive_md5_ctx *ctx) 298{ 299 (void)ctx; /* UNUSED */ 300 return (ARCHIVE_FAILED); 301} 302 303static 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 313static 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 326static int 327__archive_ripemd160init(archive_rmd160_ctx *ctx) 328{ 329 RMD160Init(ctx); 330 return (ARCHIVE_OK); 331} 332 333static 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 341static 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 350static int 351__archive_ripemd160init(archive_rmd160_ctx *ctx) 352{ 353 RIPEMD160_Init(ctx); 354 return (ARCHIVE_OK); 355} 356 357static 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 365static 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 374static 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 384static 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 394static 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 408static int 409__archive_ripemd160init(archive_rmd160_ctx *ctx) 410{ 411 ripemd160_init(ctx); 412 return (ARCHIVE_OK); 413} 414 415static 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 423static 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 432static 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 441static 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 449static 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 462static int 463__archive_ripemd160init(archive_rmd160_ctx *ctx) 464{ 465 (void)ctx; /* UNUSED */ 466 return (ARCHIVE_FAILED); 467} 468 469static 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 479static 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 492static int 493__archive_sha1init(archive_sha1_ctx *ctx) 494{ 495 SHA1Init(ctx); 496 return (ARCHIVE_OK); 497} 498 499static 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 507static 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 516static int 517__archive_sha1init(archive_sha1_ctx *ctx) 518{ 519 SHA1_Init(ctx); 520 return (ARCHIVE_OK); 521} 522 523static 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 531static 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 540static int 541__archive_sha1init(archive_sha1_ctx *ctx) 542{ 543 CC_SHA1_Init(ctx); 544 return (ARCHIVE_OK); 545} 546 547static 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 555static 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 564static 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 574static 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 584static 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 598static int 599__archive_sha1init(archive_sha1_ctx *ctx) 600{ 601 sha1_init(ctx); 602 return (ARCHIVE_OK); 603} 604 605static 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 613static 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 622static 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 631static 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 639static 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 656static int 657__archive_sha1init(archive_sha1_ctx *ctx) 658{ 659 return (win_crypto_init(ctx, CALG_SHA1)); 660} 661 662static 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 669static int 670__archive_sha1final(archive_sha1_ctx *ctx, void *md) 671{ 672 return (win_crypto_Final(md, 20, ctx)); 673} 674 675#else 676 677static int 678__archive_sha1init(archive_sha1_ctx *ctx) 679{ 680 (void)ctx; /* UNUSED */ 681 return (ARCHIVE_FAILED); 682} 683 684static 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 694static 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 707static int 708__archive_sha256init(archive_sha256_ctx *ctx) 709{ 710 SHA256_Init(ctx); 711 return (ARCHIVE_OK); 712} 713 714static 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 722static 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 731static int 732__archive_sha256init(archive_sha256_ctx *ctx) 733{ 734 SHA256Init(ctx); 735 return (ARCHIVE_OK); 736} 737 738static 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 746static 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 755static int 756__archive_sha256init(archive_sha256_ctx *ctx) 757{ 758 SHA256Init(ctx); 759 return (ARCHIVE_OK); 760} 761 762static 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 770static 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 779static int 780__archive_sha256init(archive_sha256_ctx *ctx) 781{ 782 SHA256_Init(ctx); 783 return (ARCHIVE_OK); 784} 785 786static 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 794static 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 803static int 804__archive_sha256init(archive_sha256_ctx *ctx) 805{ 806 CC_SHA256_Init(ctx); 807 return (ARCHIVE_OK); 808} 809 810static 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 818static 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 827static 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 837static 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 847static 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 861static int 862__archive_sha256init(archive_sha256_ctx *ctx) 863{ 864 sha256_init(ctx); 865 return (ARCHIVE_OK); 866} 867 868static 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 876static 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 885static 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 894static 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 902static 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 915static int 916__archive_sha256init(archive_sha256_ctx *ctx) 917{ 918 return (win_crypto_init(ctx, CALG_SHA_256)); 919} 920 921static 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 928static int 929__archive_sha256final(archive_sha256_ctx *ctx, void *md) 930{ 931 return (win_crypto_Final(md, 32, ctx)); 932} 933 934#else 935 936static int 937__archive_sha256init(archive_sha256_ctx *ctx) 938{ 939 (void)ctx; /* UNUSED */ 940 return (ARCHIVE_FAILED); 941} 942 943static 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 953static 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 966static int 967__archive_sha384init(archive_sha384_ctx *ctx) 968{ 969 SHA384_Init(ctx); 970 return (ARCHIVE_OK); 971} 972 973static 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 981static 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 990static int 991__archive_sha384init(archive_sha384_ctx *ctx) 992{ 993 SHA384Init(ctx); 994 return (ARCHIVE_OK); 995} 996 997static 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 1005static 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 1014static int 1015__archive_sha384init(archive_sha384_ctx *ctx) 1016{ 1017 SHA384Init(ctx); 1018 return (ARCHIVE_OK); 1019} 1020 1021static 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 1029static 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 1038static int 1039__archive_sha384init(archive_sha384_ctx *ctx) 1040{ 1041 CC_SHA384_Init(ctx); 1042 return (ARCHIVE_OK); 1043} 1044 1045static 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 1053static 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 1062static 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 1072static 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 1082static 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 1096static int 1097__archive_sha384init(archive_sha384_ctx *ctx) 1098{ 1099 sha384_init(ctx); 1100 return (ARCHIVE_OK); 1101} 1102 1103static 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 1111static 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 1120static 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 1129static 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 1137static 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 1150static int 1151__archive_sha384init(archive_sha384_ctx *ctx) 1152{ 1153 return (win_crypto_init(ctx, CALG_SHA_384)); 1154} 1155 1156static 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 1163static int 1164__archive_sha384final(archive_sha384_ctx *ctx, void *md) 1165{ 1166 return (win_crypto_Final(md, 48, ctx)); 1167} 1168 1169#else 1170 1171static int 1172__archive_sha384init(archive_sha384_ctx *ctx) 1173{ 1174 (void)ctx; /* UNUSED */ 1175 return (ARCHIVE_FAILED); 1176} 1177 1178static 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 1188static 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 1201static int 1202__archive_sha512init(archive_sha512_ctx *ctx) 1203{ 1204 SHA512_Init(ctx); 1205 return (ARCHIVE_OK); 1206} 1207 1208static 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 1216static 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 1225static int 1226__archive_sha512init(archive_sha512_ctx *ctx) 1227{ 1228 SHA512Init(ctx); 1229 return (ARCHIVE_OK); 1230} 1231 1232static 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 1240static 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 1249static int 1250__archive_sha512init(archive_sha512_ctx *ctx) 1251{ 1252 SHA512Init(ctx); 1253 return (ARCHIVE_OK); 1254} 1255 1256static 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 1264static 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 1273static int 1274__archive_sha512init(archive_sha512_ctx *ctx) 1275{ 1276 SHA512_Init(ctx); 1277 return (ARCHIVE_OK); 1278} 1279 1280static 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 1288static 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 1297static int 1298__archive_sha512init(archive_sha512_ctx *ctx) 1299{ 1300 CC_SHA512_Init(ctx); 1301 return (ARCHIVE_OK); 1302} 1303 1304static 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 1312static 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 1321static 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 1331static 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 1341static 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 1355static int 1356__archive_sha512init(archive_sha512_ctx *ctx) 1357{ 1358 sha512_init(ctx); 1359 return (ARCHIVE_OK); 1360} 1361 1362static 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 1370static 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 1379static 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 1388static 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 1396static 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 1409static int 1410__archive_sha512init(archive_sha512_ctx *ctx) 1411{ 1412 return (win_crypto_init(ctx, CALG_SHA_512)); 1413} 1414 1415static 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 1422static int 1423__archive_sha512final(archive_sha512_ctx *ctx, void *md) 1424{ 1425 return (win_crypto_Final(md, 64, ctx)); 1426} 1427 1428#else 1429 1430static int 1431__archive_sha512init(archive_sha512_ctx *ctx) 1432{ 1433 (void)ctx; /* UNUSED */ 1434 return (ARCHIVE_FAILED); 1435} 1436 1437static 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 1447static 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 */ 1468const 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