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