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