contrib/libarchive/libarchive/archive_digest.c

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