2 * Copyright (c) 2003-2007 Tim Kientzle
3 * Copyright (c) 2011 Andres Mejia
4 * Copyright (c) 2011 Michihiro NAKAJIMA
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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.
28 #include "archive_platform.h"
31 #include "archive_digest_private.h"
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.
40 * Message digest functions for Windows platform.
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)
49 * Initialize a Message digest.
52 win_crypto_init(Digest_CTX *ctx, ALG_ID algId)
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);
65 if (!CryptCreateHash(ctx->cryptProv, algId, 0, 0, &ctx->hash)) {
66 CryptReleaseContext(ctx->cryptProv, 0);
67 return (ARCHIVE_FAILED);
75 * Update a Message digest.
78 win_crypto_Update(Digest_CTX *ctx, const unsigned char *buf, size_t len)
82 return (ARCHIVE_FAILED);
84 CryptHashData(ctx->hash,
85 (unsigned char *)(uintptr_t)buf,
91 win_crypto_Final(unsigned char *buf, size_t bufsize, Digest_CTX *ctx)
93 DWORD siglen = (DWORD)bufsize;
96 return (ARCHIVE_FAILED);
98 CryptGetHashParam(ctx->hash, HP_HASHVAL, buf, &siglen, 0);
99 CryptDestroyHash(ctx->hash);
100 CryptReleaseContext(ctx->cryptProv, 0);
105 #endif /* defined(ARCHIVE_CRYPTO_*_WIN) */
108 /* MD5 implementations */
109 #if defined(ARCHIVE_CRYPTO_MD5_LIBC)
112 __archive_libc_md5init(archive_md5_ctx *ctx)
119 __archive_libc_md5update(archive_md5_ctx *ctx, const void *indata,
122 MD5Update(ctx, indata, insize);
127 __archive_libc_md5final(archive_md5_ctx *ctx, void *md)
133 #elif defined(ARCHIVE_CRYPTO_MD5_LIBMD)
136 __archive_libmd_md5init(archive_md5_ctx *ctx)
143 __archive_libmd_md5update(archive_md5_ctx *ctx, const void *indata,
146 MD5Update(ctx, indata, insize);
151 __archive_libmd_md5final(archive_md5_ctx *ctx, void *md)
157 #elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM)
160 __archive_libsystem_md5init(archive_md5_ctx *ctx)
167 __archive_libsystem_md5update(archive_md5_ctx *ctx, const void *indata,
170 CC_MD5_Update(ctx, indata, insize);
175 __archive_libsystem_md5final(archive_md5_ctx *ctx, void *md)
177 CC_MD5_Final(md, ctx);
181 #elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
184 __archive_nettle_md5init(archive_md5_ctx *ctx)
191 __archive_nettle_md5update(archive_md5_ctx *ctx, const void *indata,
194 md5_update(ctx, insize, indata);
199 __archive_nettle_md5final(archive_md5_ctx *ctx, void *md)
201 md5_digest(ctx, MD5_DIGEST_SIZE, md);
205 #elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
208 __archive_openssl_md5init(archive_md5_ctx *ctx)
210 if ((*ctx = EVP_MD_CTX_new()) == NULL)
211 return (ARCHIVE_FAILED);
212 EVP_DigestInit(*ctx, EVP_md5());
217 __archive_openssl_md5update(archive_md5_ctx *ctx, const void *indata,
220 EVP_DigestUpdate(*ctx, indata, insize);
225 __archive_openssl_md5final(archive_md5_ctx *ctx, void *md)
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
232 EVP_DigestFinal(*ctx, md, NULL);
233 EVP_MD_CTX_free(*ctx);
239 #elif defined(ARCHIVE_CRYPTO_MD5_WIN)
242 __archive_windowsapi_md5init(archive_md5_ctx *ctx)
244 return (win_crypto_init(ctx, CALG_MD5));
248 __archive_windowsapi_md5update(archive_md5_ctx *ctx, const void *indata,
251 return (win_crypto_Update(ctx, indata, insize));
255 __archive_windowsapi_md5final(archive_md5_ctx *ctx, void *md)
257 return (win_crypto_Final(md, 16, ctx));
263 __archive_stub_md5init(archive_md5_ctx *ctx)
265 (void)ctx; /* UNUSED */
266 return (ARCHIVE_FAILED);
270 __archive_stub_md5update(archive_md5_ctx *ctx, const void *indata,
273 (void)ctx; /* UNUSED */
274 (void)indata; /* UNUSED */
275 (void)insize; /* UNUSED */
276 return (ARCHIVE_FAILED);
280 __archive_stub_md5final(archive_md5_ctx *ctx, void *md)
282 (void)ctx; /* UNUSED */
283 (void)md; /* UNUSED */
284 return (ARCHIVE_FAILED);
289 /* RIPEMD160 implementations */
290 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
293 __archive_libc_ripemd160init(archive_rmd160_ctx *ctx)
300 __archive_libc_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
303 RMD160Update(ctx, indata, insize);
308 __archive_libc_ripemd160final(archive_rmd160_ctx *ctx, void *md)
310 RMD160Final(md, ctx);
314 #elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
317 __archive_libmd_ripemd160init(archive_rmd160_ctx *ctx)
324 __archive_libmd_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
327 RIPEMD160_Update(ctx, indata, insize);
332 __archive_libmd_ripemd160final(archive_rmd160_ctx *ctx, void *md)
334 RIPEMD160_Final(md, ctx);
338 #elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
341 __archive_nettle_ripemd160init(archive_rmd160_ctx *ctx)
348 __archive_nettle_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
351 ripemd160_update(ctx, insize, indata);
356 __archive_nettle_ripemd160final(archive_rmd160_ctx *ctx, void *md)
358 ripemd160_digest(ctx, RIPEMD160_DIGEST_SIZE, md);
362 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
365 __archive_openssl_ripemd160init(archive_rmd160_ctx *ctx)
367 if ((*ctx = EVP_MD_CTX_new()) == NULL)
368 return (ARCHIVE_FAILED);
369 EVP_DigestInit(*ctx, EVP_ripemd160());
374 __archive_openssl_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
377 EVP_DigestUpdate(*ctx, indata, insize);
382 __archive_openssl_ripemd160final(archive_rmd160_ctx *ctx, void *md)
385 EVP_DigestFinal(*ctx, md, NULL);
386 EVP_MD_CTX_free(*ctx);
395 __archive_stub_ripemd160init(archive_rmd160_ctx *ctx)
397 (void)ctx; /* UNUSED */
398 return (ARCHIVE_FAILED);
402 __archive_stub_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
405 (void)ctx; /* UNUSED */
406 (void)indata; /* UNUSED */
407 (void)insize; /* UNUSED */
408 return (ARCHIVE_FAILED);
412 __archive_stub_ripemd160final(archive_rmd160_ctx *ctx, void *md)
414 (void)ctx; /* UNUSED */
415 (void)md; /* UNUSED */
416 return (ARCHIVE_FAILED);
421 /* SHA1 implementations */
422 #if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
425 __archive_libc_sha1init(archive_sha1_ctx *ctx)
432 __archive_libc_sha1update(archive_sha1_ctx *ctx, const void *indata,
435 SHA1Update(ctx, indata, insize);
440 __archive_libc_sha1final(archive_sha1_ctx *ctx, void *md)
446 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
449 __archive_libmd_sha1init(archive_sha1_ctx *ctx)
456 __archive_libmd_sha1update(archive_sha1_ctx *ctx, const void *indata,
459 SHA1_Update(ctx, indata, insize);
464 __archive_libmd_sha1final(archive_sha1_ctx *ctx, void *md)
470 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
473 __archive_libsystem_sha1init(archive_sha1_ctx *ctx)
480 __archive_libsystem_sha1update(archive_sha1_ctx *ctx, const void *indata,
483 CC_SHA1_Update(ctx, indata, insize);
488 __archive_libsystem_sha1final(archive_sha1_ctx *ctx, void *md)
490 CC_SHA1_Final(md, ctx);
494 #elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
497 __archive_nettle_sha1init(archive_sha1_ctx *ctx)
504 __archive_nettle_sha1update(archive_sha1_ctx *ctx, const void *indata,
507 sha1_update(ctx, insize, indata);
512 __archive_nettle_sha1final(archive_sha1_ctx *ctx, void *md)
514 sha1_digest(ctx, SHA1_DIGEST_SIZE, md);
518 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
521 __archive_openssl_sha1init(archive_sha1_ctx *ctx)
523 if ((*ctx = EVP_MD_CTX_new()) == NULL)
524 return (ARCHIVE_FAILED);
525 EVP_DigestInit(*ctx, EVP_sha1());
530 __archive_openssl_sha1update(archive_sha1_ctx *ctx, const void *indata,
533 EVP_DigestUpdate(*ctx, indata, insize);
538 __archive_openssl_sha1final(archive_sha1_ctx *ctx, void *md)
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
545 EVP_DigestFinal(*ctx, md, NULL);
546 EVP_MD_CTX_free(*ctx);
552 #elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
555 __archive_windowsapi_sha1init(archive_sha1_ctx *ctx)
557 return (win_crypto_init(ctx, CALG_SHA1));
561 __archive_windowsapi_sha1update(archive_sha1_ctx *ctx, const void *indata,
564 return (win_crypto_Update(ctx, indata, insize));
568 __archive_windowsapi_sha1final(archive_sha1_ctx *ctx, void *md)
570 return (win_crypto_Final(md, 20, ctx));
576 __archive_stub_sha1init(archive_sha1_ctx *ctx)
578 (void)ctx; /* UNUSED */
579 return (ARCHIVE_FAILED);
583 __archive_stub_sha1update(archive_sha1_ctx *ctx, const void *indata,
586 (void)ctx; /* UNUSED */
587 (void)indata; /* UNUSED */
588 (void)insize; /* UNUSED */
589 return (ARCHIVE_FAILED);
593 __archive_stub_sha1final(archive_sha1_ctx *ctx, void *md)
595 (void)ctx; /* UNUSED */
596 (void)md; /* UNUSED */
597 return (ARCHIVE_FAILED);
602 /* SHA256 implementations */
603 #if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
606 __archive_libc_sha256init(archive_sha256_ctx *ctx)
613 __archive_libc_sha256update(archive_sha256_ctx *ctx, const void *indata,
616 SHA256_Update(ctx, indata, insize);
621 __archive_libc_sha256final(archive_sha256_ctx *ctx, void *md)
623 SHA256_Final(md, ctx);
627 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
630 __archive_libc2_sha256init(archive_sha256_ctx *ctx)
637 __archive_libc2_sha256update(archive_sha256_ctx *ctx, const void *indata,
640 SHA256Update(ctx, indata, insize);
645 __archive_libc2_sha256final(archive_sha256_ctx *ctx, void *md)
647 SHA256Final(md, ctx);
651 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
654 __archive_libc3_sha256init(archive_sha256_ctx *ctx)
661 __archive_libc3_sha256update(archive_sha256_ctx *ctx, const void *indata,
664 SHA256Update(ctx, indata, insize);
669 __archive_libc3_sha256final(archive_sha256_ctx *ctx, void *md)
671 SHA256Final(md, ctx);
675 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
678 __archive_libmd_sha256init(archive_sha256_ctx *ctx)
685 __archive_libmd_sha256update(archive_sha256_ctx *ctx, const void *indata,
688 SHA256_Update(ctx, indata, insize);
693 __archive_libmd_sha256final(archive_sha256_ctx *ctx, void *md)
695 SHA256_Final(md, ctx);
699 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
702 __archive_libsystem_sha256init(archive_sha256_ctx *ctx)
709 __archive_libsystem_sha256update(archive_sha256_ctx *ctx, const void *indata,
712 CC_SHA256_Update(ctx, indata, insize);
717 __archive_libsystem_sha256final(archive_sha256_ctx *ctx, void *md)
719 CC_SHA256_Final(md, ctx);
723 #elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
726 __archive_nettle_sha256init(archive_sha256_ctx *ctx)
733 __archive_nettle_sha256update(archive_sha256_ctx *ctx, const void *indata,
736 sha256_update(ctx, insize, indata);
741 __archive_nettle_sha256final(archive_sha256_ctx *ctx, void *md)
743 sha256_digest(ctx, SHA256_DIGEST_SIZE, md);
747 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
750 __archive_openssl_sha256init(archive_sha256_ctx *ctx)
752 if ((*ctx = EVP_MD_CTX_new()) == NULL)
753 return (ARCHIVE_FAILED);
754 EVP_DigestInit(*ctx, EVP_sha256());
759 __archive_openssl_sha256update(archive_sha256_ctx *ctx, const void *indata,
762 EVP_DigestUpdate(*ctx, indata, insize);
767 __archive_openssl_sha256final(archive_sha256_ctx *ctx, void *md)
770 EVP_DigestFinal(*ctx, md, NULL);
771 EVP_MD_CTX_free(*ctx);
777 #elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
780 __archive_windowsapi_sha256init(archive_sha256_ctx *ctx)
782 return (win_crypto_init(ctx, CALG_SHA_256));
786 __archive_windowsapi_sha256update(archive_sha256_ctx *ctx, const void *indata,
789 return (win_crypto_Update(ctx, indata, insize));
793 __archive_windowsapi_sha256final(archive_sha256_ctx *ctx, void *md)
795 return (win_crypto_Final(md, 32, ctx));
801 __archive_stub_sha256init(archive_sha256_ctx *ctx)
803 (void)ctx; /* UNUSED */
804 return (ARCHIVE_FAILED);
808 __archive_stub_sha256update(archive_sha256_ctx *ctx, const void *indata,
811 (void)ctx; /* UNUSED */
812 (void)indata; /* UNUSED */
813 (void)insize; /* UNUSED */
814 return (ARCHIVE_FAILED);
818 __archive_stub_sha256final(archive_sha256_ctx *ctx, void *md)
820 (void)ctx; /* UNUSED */
821 (void)md; /* UNUSED */
822 return (ARCHIVE_FAILED);
827 /* SHA384 implementations */
828 #if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
831 __archive_libc_sha384init(archive_sha384_ctx *ctx)
838 __archive_libc_sha384update(archive_sha384_ctx *ctx, const void *indata,
841 SHA384_Update(ctx, indata, insize);
846 __archive_libc_sha384final(archive_sha384_ctx *ctx, void *md)
848 SHA384_Final(md, ctx);
852 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
855 __archive_libc2_sha384init(archive_sha384_ctx *ctx)
862 __archive_libc2_sha384update(archive_sha384_ctx *ctx, const void *indata,
865 SHA384Update(ctx, indata, insize);
870 __archive_libc2_sha384final(archive_sha384_ctx *ctx, void *md)
872 SHA384Final(md, ctx);
876 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
879 __archive_libc3_sha384init(archive_sha384_ctx *ctx)
886 __archive_libc3_sha384update(archive_sha384_ctx *ctx, const void *indata,
889 SHA384Update(ctx, indata, insize);
894 __archive_libc3_sha384final(archive_sha384_ctx *ctx, void *md)
896 SHA384Final(md, ctx);
900 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
903 __archive_libsystem_sha384init(archive_sha384_ctx *ctx)
910 __archive_libsystem_sha384update(archive_sha384_ctx *ctx, const void *indata,
913 CC_SHA384_Update(ctx, indata, insize);
918 __archive_libsystem_sha384final(archive_sha384_ctx *ctx, void *md)
920 CC_SHA384_Final(md, ctx);
924 #elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
927 __archive_nettle_sha384init(archive_sha384_ctx *ctx)
934 __archive_nettle_sha384update(archive_sha384_ctx *ctx, const void *indata,
937 sha384_update(ctx, insize, indata);
942 __archive_nettle_sha384final(archive_sha384_ctx *ctx, void *md)
944 sha384_digest(ctx, SHA384_DIGEST_SIZE, md);
948 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
951 __archive_openssl_sha384init(archive_sha384_ctx *ctx)
953 if ((*ctx = EVP_MD_CTX_new()) == NULL)
954 return (ARCHIVE_FAILED);
955 EVP_DigestInit(*ctx, EVP_sha384());
960 __archive_openssl_sha384update(archive_sha384_ctx *ctx, const void *indata,
963 EVP_DigestUpdate(*ctx, indata, insize);
968 __archive_openssl_sha384final(archive_sha384_ctx *ctx, void *md)
971 EVP_DigestFinal(*ctx, md, NULL);
972 EVP_MD_CTX_free(*ctx);
978 #elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
981 __archive_windowsapi_sha384init(archive_sha384_ctx *ctx)
983 return (win_crypto_init(ctx, CALG_SHA_384));
987 __archive_windowsapi_sha384update(archive_sha384_ctx *ctx, const void *indata,
990 return (win_crypto_Update(ctx, indata, insize));
994 __archive_windowsapi_sha384final(archive_sha384_ctx *ctx, void *md)
996 return (win_crypto_Final(md, 48, ctx));
1002 __archive_stub_sha384init(archive_sha384_ctx *ctx)
1004 (void)ctx; /* UNUSED */
1005 return (ARCHIVE_FAILED);
1009 __archive_stub_sha384update(archive_sha384_ctx *ctx, const void *indata,
1012 (void)ctx; /* UNUSED */
1013 (void)indata; /* UNUSED */
1014 (void)insize; /* UNUSED */
1015 return (ARCHIVE_FAILED);
1019 __archive_stub_sha384final(archive_sha384_ctx *ctx, void *md)
1021 (void)ctx; /* UNUSED */
1022 (void)md; /* UNUSED */
1023 return (ARCHIVE_FAILED);
1028 /* SHA512 implementations */
1029 #if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1032 __archive_libc_sha512init(archive_sha512_ctx *ctx)
1035 return (ARCHIVE_OK);
1039 __archive_libc_sha512update(archive_sha512_ctx *ctx, const void *indata,
1042 SHA512_Update(ctx, indata, insize);
1043 return (ARCHIVE_OK);
1047 __archive_libc_sha512final(archive_sha512_ctx *ctx, void *md)
1049 SHA512_Final(md, ctx);
1050 return (ARCHIVE_OK);
1053 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1056 __archive_libc2_sha512init(archive_sha512_ctx *ctx)
1059 return (ARCHIVE_OK);
1063 __archive_libc2_sha512update(archive_sha512_ctx *ctx, const void *indata,
1066 SHA512Update(ctx, indata, insize);
1067 return (ARCHIVE_OK);
1071 __archive_libc2_sha512final(archive_sha512_ctx *ctx, void *md)
1073 SHA512Final(md, ctx);
1074 return (ARCHIVE_OK);
1077 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1080 __archive_libc3_sha512init(archive_sha512_ctx *ctx)
1083 return (ARCHIVE_OK);
1087 __archive_libc3_sha512update(archive_sha512_ctx *ctx, const void *indata,
1090 SHA512Update(ctx, indata, insize);
1091 return (ARCHIVE_OK);
1095 __archive_libc3_sha512final(archive_sha512_ctx *ctx, void *md)
1097 SHA512Final(md, ctx);
1098 return (ARCHIVE_OK);
1101 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1104 __archive_libmd_sha512init(archive_sha512_ctx *ctx)
1107 return (ARCHIVE_OK);
1111 __archive_libmd_sha512update(archive_sha512_ctx *ctx, const void *indata,
1114 SHA512_Update(ctx, indata, insize);
1115 return (ARCHIVE_OK);
1119 __archive_libmd_sha512final(archive_sha512_ctx *ctx, void *md)
1121 SHA512_Final(md, ctx);
1122 return (ARCHIVE_OK);
1125 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1128 __archive_libsystem_sha512init(archive_sha512_ctx *ctx)
1130 CC_SHA512_Init(ctx);
1131 return (ARCHIVE_OK);
1135 __archive_libsystem_sha512update(archive_sha512_ctx *ctx, const void *indata,
1138 CC_SHA512_Update(ctx, indata, insize);
1139 return (ARCHIVE_OK);
1143 __archive_libsystem_sha512final(archive_sha512_ctx *ctx, void *md)
1145 CC_SHA512_Final(md, ctx);
1146 return (ARCHIVE_OK);
1149 #elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1152 __archive_nettle_sha512init(archive_sha512_ctx *ctx)
1155 return (ARCHIVE_OK);
1159 __archive_nettle_sha512update(archive_sha512_ctx *ctx, const void *indata,
1162 sha512_update(ctx, insize, indata);
1163 return (ARCHIVE_OK);
1167 __archive_nettle_sha512final(archive_sha512_ctx *ctx, void *md)
1169 sha512_digest(ctx, SHA512_DIGEST_SIZE, md);
1170 return (ARCHIVE_OK);
1173 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1176 __archive_openssl_sha512init(archive_sha512_ctx *ctx)
1178 if ((*ctx = EVP_MD_CTX_new()) == NULL)
1179 return (ARCHIVE_FAILED);
1180 EVP_DigestInit(*ctx, EVP_sha512());
1181 return (ARCHIVE_OK);
1185 __archive_openssl_sha512update(archive_sha512_ctx *ctx, const void *indata,
1188 EVP_DigestUpdate(*ctx, indata, insize);
1189 return (ARCHIVE_OK);
1193 __archive_openssl_sha512final(archive_sha512_ctx *ctx, void *md)
1196 EVP_DigestFinal(*ctx, md, NULL);
1197 EVP_MD_CTX_free(*ctx);
1200 return (ARCHIVE_OK);
1203 #elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1206 __archive_windowsapi_sha512init(archive_sha512_ctx *ctx)
1208 return (win_crypto_init(ctx, CALG_SHA_512));
1212 __archive_windowsapi_sha512update(archive_sha512_ctx *ctx, const void *indata,
1215 return (win_crypto_Update(ctx, indata, insize));
1219 __archive_windowsapi_sha512final(archive_sha512_ctx *ctx, void *md)
1221 return (win_crypto_Final(md, 64, ctx));
1227 __archive_stub_sha512init(archive_sha512_ctx *ctx)
1229 (void)ctx; /* UNUSED */
1230 return (ARCHIVE_FAILED);
1234 __archive_stub_sha512update(archive_sha512_ctx *ctx, const void *indata,
1237 (void)ctx; /* UNUSED */
1238 (void)indata; /* UNUSED */
1239 (void)insize; /* UNUSED */
1240 return (ARCHIVE_FAILED);
1244 __archive_stub_sha512final(archive_sha512_ctx *ctx, void *md)
1246 (void)ctx; /* UNUSED */
1247 (void)md; /* UNUSED */
1248 return (ARCHIVE_FAILED);
1253 /* NOTE: Message Digest functions are set based on availability and by the
1254 * following order of preference.
1264 const struct archive_digest __archive_digest =
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,
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,
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,
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,
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,
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