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_crypto_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 EVP_DigestInit(ctx, EVP_md5());
215 __archive_openssl_md5update(archive_md5_ctx *ctx, const void *indata,
218 EVP_DigestUpdate(ctx, indata, insize);
223 __archive_openssl_md5final(archive_md5_ctx *ctx, void *md)
225 /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
226 * this is meant to cope with that. Real fix is probably to fix
227 * archive_write_set_format_xar.c
230 EVP_DigestFinal(ctx, md, NULL);
234 #elif defined(ARCHIVE_CRYPTO_MD5_WIN)
237 __archive_windowsapi_md5init(archive_md5_ctx *ctx)
239 return (win_crypto_init(ctx, CALG_MD5));
243 __archive_windowsapi_md5update(archive_md5_ctx *ctx, const void *indata,
246 return (win_crypto_Update(ctx, indata, insize));
250 __archive_windowsapi_md5final(archive_md5_ctx *ctx, void *md)
252 return (win_crypto_Final(md, 16, ctx));
258 __archive_stub_md5init(archive_md5_ctx *ctx)
260 (void)ctx; /* UNUSED */
261 return (ARCHIVE_FAILED);
265 __archive_stub_md5update(archive_md5_ctx *ctx, const void *indata,
268 (void)ctx; /* UNUSED */
269 (void)indata; /* UNUSED */
270 (void)insize; /* UNUSED */
271 return (ARCHIVE_FAILED);
275 __archive_stub_md5final(archive_md5_ctx *ctx, void *md)
277 (void)ctx; /* UNUSED */
278 (void)md; /* UNUSED */
279 return (ARCHIVE_FAILED);
284 /* RIPEMD160 implementations */
285 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
288 __archive_libc_ripemd160init(archive_rmd160_ctx *ctx)
295 __archive_libc_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
298 RMD160Update(ctx, indata, insize);
303 __archive_libc_ripemd160final(archive_rmd160_ctx *ctx, void *md)
305 RMD160Final(md, ctx);
309 #elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
312 __archive_libmd_ripemd160init(archive_rmd160_ctx *ctx)
319 __archive_libmd_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
322 RIPEMD160_Update(ctx, indata, insize);
327 __archive_libmd_ripemd160final(archive_rmd160_ctx *ctx, void *md)
329 RIPEMD160_Final(md, ctx);
333 #elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
336 __archive_nettle_ripemd160init(archive_rmd160_ctx *ctx)
343 __archive_nettle_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
346 ripemd160_update(ctx, insize, indata);
351 __archive_nettle_ripemd160final(archive_rmd160_ctx *ctx, void *md)
353 ripemd160_digest(ctx, RIPEMD160_DIGEST_SIZE, md);
357 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
360 __archive_openssl_ripemd160init(archive_rmd160_ctx *ctx)
362 EVP_DigestInit(ctx, EVP_ripemd160());
367 __archive_openssl_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
370 EVP_DigestUpdate(ctx, indata, insize);
375 __archive_openssl_ripemd160final(archive_rmd160_ctx *ctx, void *md)
377 EVP_DigestFinal(ctx, md, NULL);
384 __archive_stub_ripemd160init(archive_rmd160_ctx *ctx)
386 (void)ctx; /* UNUSED */
387 return (ARCHIVE_FAILED);
391 __archive_stub_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
394 (void)ctx; /* UNUSED */
395 (void)indata; /* UNUSED */
396 (void)insize; /* UNUSED */
397 return (ARCHIVE_FAILED);
401 __archive_stub_ripemd160final(archive_rmd160_ctx *ctx, void *md)
403 (void)ctx; /* UNUSED */
404 (void)md; /* UNUSED */
405 return (ARCHIVE_FAILED);
410 /* SHA1 implementations */
411 #if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
414 __archive_libc_sha1init(archive_sha1_ctx *ctx)
421 __archive_libc_sha1update(archive_sha1_ctx *ctx, const void *indata,
424 SHA1Update(ctx, indata, insize);
429 __archive_libc_sha1final(archive_sha1_ctx *ctx, void *md)
435 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
438 __archive_libmd_sha1init(archive_sha1_ctx *ctx)
445 __archive_libmd_sha1update(archive_sha1_ctx *ctx, const void *indata,
448 SHA1_Update(ctx, indata, insize);
453 __archive_libmd_sha1final(archive_sha1_ctx *ctx, void *md)
459 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
462 __archive_libsystem_sha1init(archive_sha1_ctx *ctx)
469 __archive_libsystem_sha1update(archive_sha1_ctx *ctx, const void *indata,
472 CC_SHA1_Update(ctx, indata, insize);
477 __archive_libsystem_sha1final(archive_sha1_ctx *ctx, void *md)
479 CC_SHA1_Final(md, ctx);
483 #elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
486 __archive_nettle_sha1init(archive_sha1_ctx *ctx)
493 __archive_nettle_sha1update(archive_sha1_ctx *ctx, const void *indata,
496 sha1_update(ctx, insize, indata);
501 __archive_nettle_sha1final(archive_sha1_ctx *ctx, void *md)
503 sha1_digest(ctx, SHA1_DIGEST_SIZE, md);
507 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
510 __archive_openssl_sha1init(archive_sha1_ctx *ctx)
512 EVP_DigestInit(ctx, EVP_sha1());
517 __archive_openssl_sha1update(archive_sha1_ctx *ctx, const void *indata,
520 EVP_DigestUpdate(ctx, indata, insize);
525 __archive_openssl_sha1final(archive_sha1_ctx *ctx, void *md)
527 /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
528 * this is meant to cope with that. Real fix is probably to fix
529 * archive_write_set_format_xar.c
532 EVP_DigestFinal(ctx, md, NULL);
536 #elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
539 __archive_windowsapi_sha1init(archive_sha1_ctx *ctx)
541 return (win_crypto_init(ctx, CALG_SHA1));
545 __archive_windowsapi_sha1update(archive_sha1_ctx *ctx, const void *indata,
548 return (win_crypto_Update(ctx, indata, insize));
552 __archive_windowsapi_sha1final(archive_sha1_ctx *ctx, void *md)
554 return (win_crypto_Final(md, 20, ctx));
560 __archive_stub_sha1init(archive_sha1_ctx *ctx)
562 (void)ctx; /* UNUSED */
563 return (ARCHIVE_FAILED);
567 __archive_stub_sha1update(archive_sha1_ctx *ctx, const void *indata,
570 (void)ctx; /* UNUSED */
571 (void)indata; /* UNUSED */
572 (void)insize; /* UNUSED */
573 return (ARCHIVE_FAILED);
577 __archive_stub_sha1final(archive_sha1_ctx *ctx, void *md)
579 (void)ctx; /* UNUSED */
580 (void)md; /* UNUSED */
581 return (ARCHIVE_FAILED);
586 /* SHA256 implementations */
587 #if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
590 __archive_libc_sha256init(archive_sha256_ctx *ctx)
597 __archive_libc_sha256update(archive_sha256_ctx *ctx, const void *indata,
600 SHA256_Update(ctx, indata, insize);
605 __archive_libc_sha256final(archive_sha256_ctx *ctx, void *md)
607 SHA256_Final(md, ctx);
611 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
614 __archive_libc2_sha256init(archive_sha256_ctx *ctx)
621 __archive_libc2_sha256update(archive_sha256_ctx *ctx, const void *indata,
624 SHA256Update(ctx, indata, insize);
629 __archive_libc2_sha256final(archive_sha256_ctx *ctx, void *md)
631 SHA256Final(md, ctx);
635 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
638 __archive_libc3_sha256init(archive_sha256_ctx *ctx)
645 __archive_libc3_sha256update(archive_sha256_ctx *ctx, const void *indata,
648 SHA256Update(ctx, indata, insize);
653 __archive_libc3_sha256final(archive_sha256_ctx *ctx, void *md)
655 SHA256Final(md, ctx);
659 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
662 __archive_libmd_sha256init(archive_sha256_ctx *ctx)
669 __archive_libmd_sha256update(archive_sha256_ctx *ctx, const void *indata,
672 SHA256_Update(ctx, indata, insize);
677 __archive_libmd_sha256final(archive_sha256_ctx *ctx, void *md)
679 SHA256_Final(md, ctx);
683 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
686 __archive_libsystem_sha256init(archive_sha256_ctx *ctx)
693 __archive_libsystem_sha256update(archive_sha256_ctx *ctx, const void *indata,
696 CC_SHA256_Update(ctx, indata, insize);
701 __archive_libsystem_sha256final(archive_sha256_ctx *ctx, void *md)
703 CC_SHA256_Final(md, ctx);
707 #elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
710 __archive_nettle_sha256init(archive_sha256_ctx *ctx)
717 __archive_nettle_sha256update(archive_sha256_ctx *ctx, const void *indata,
720 sha256_update(ctx, insize, indata);
725 __archive_nettle_sha256final(archive_sha256_ctx *ctx, void *md)
727 sha256_digest(ctx, SHA256_DIGEST_SIZE, md);
731 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
734 __archive_openssl_sha256init(archive_sha256_ctx *ctx)
736 EVP_DigestInit(ctx, EVP_sha256());
741 __archive_openssl_sha256update(archive_sha256_ctx *ctx, const void *indata,
744 EVP_DigestUpdate(ctx, indata, insize);
749 __archive_openssl_sha256final(archive_sha256_ctx *ctx, void *md)
751 EVP_DigestFinal(ctx, md, NULL);
755 #elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
758 __archive_windowsapi_sha256init(archive_sha256_ctx *ctx)
760 return (win_crypto_init(ctx, CALG_SHA_256));
764 __archive_windowsapi_sha256update(archive_sha256_ctx *ctx, const void *indata,
767 return (win_crypto_Update(ctx, indata, insize));
771 __archive_windowsapi_sha256final(archive_sha256_ctx *ctx, void *md)
773 return (win_crypto_Final(md, 32, ctx));
779 __archive_stub_sha256init(archive_sha256_ctx *ctx)
781 (void)ctx; /* UNUSED */
782 return (ARCHIVE_FAILED);
786 __archive_stub_sha256update(archive_sha256_ctx *ctx, const void *indata,
789 (void)ctx; /* UNUSED */
790 (void)indata; /* UNUSED */
791 (void)insize; /* UNUSED */
792 return (ARCHIVE_FAILED);
796 __archive_stub_sha256final(archive_sha256_ctx *ctx, void *md)
798 (void)ctx; /* UNUSED */
799 (void)md; /* UNUSED */
800 return (ARCHIVE_FAILED);
805 /* SHA384 implementations */
806 #if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
809 __archive_libc_sha384init(archive_sha384_ctx *ctx)
816 __archive_libc_sha384update(archive_sha384_ctx *ctx, const void *indata,
819 SHA384_Update(ctx, indata, insize);
824 __archive_libc_sha384final(archive_sha384_ctx *ctx, void *md)
826 SHA384_Final(md, ctx);
830 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
833 __archive_libc2_sha384init(archive_sha384_ctx *ctx)
840 __archive_libc2_sha384update(archive_sha384_ctx *ctx, const void *indata,
843 SHA384Update(ctx, indata, insize);
848 __archive_libc2_sha384final(archive_sha384_ctx *ctx, void *md)
850 SHA384Final(md, ctx);
854 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
857 __archive_libc3_sha384init(archive_sha384_ctx *ctx)
864 __archive_libc3_sha384update(archive_sha384_ctx *ctx, const void *indata,
867 SHA384Update(ctx, indata, insize);
872 __archive_libc3_sha384final(archive_sha384_ctx *ctx, void *md)
874 SHA384Final(md, ctx);
878 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
881 __archive_libsystem_sha384init(archive_sha384_ctx *ctx)
888 __archive_libsystem_sha384update(archive_sha384_ctx *ctx, const void *indata,
891 CC_SHA384_Update(ctx, indata, insize);
896 __archive_libsystem_sha384final(archive_sha384_ctx *ctx, void *md)
898 CC_SHA384_Final(md, ctx);
902 #elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
905 __archive_nettle_sha384init(archive_sha384_ctx *ctx)
912 __archive_nettle_sha384update(archive_sha384_ctx *ctx, const void *indata,
915 sha384_update(ctx, insize, indata);
920 __archive_nettle_sha384final(archive_sha384_ctx *ctx, void *md)
922 sha384_digest(ctx, SHA384_DIGEST_SIZE, md);
926 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
929 __archive_openssl_sha384init(archive_sha384_ctx *ctx)
931 EVP_DigestInit(ctx, EVP_sha384());
936 __archive_openssl_sha384update(archive_sha384_ctx *ctx, const void *indata,
939 EVP_DigestUpdate(ctx, indata, insize);
944 __archive_openssl_sha384final(archive_sha384_ctx *ctx, void *md)
946 EVP_DigestFinal(ctx, md, NULL);
950 #elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
953 __archive_windowsapi_sha384init(archive_sha384_ctx *ctx)
955 return (win_crypto_init(ctx, CALG_SHA_384));
959 __archive_windowsapi_sha384update(archive_sha384_ctx *ctx, const void *indata,
962 return (win_crypto_Update(ctx, indata, insize));
966 __archive_windowsapi_sha384final(archive_sha384_ctx *ctx, void *md)
968 return (win_crypto_Final(md, 48, ctx));
974 __archive_stub_sha384init(archive_sha384_ctx *ctx)
976 (void)ctx; /* UNUSED */
977 return (ARCHIVE_FAILED);
981 __archive_stub_sha384update(archive_sha384_ctx *ctx, const void *indata,
984 (void)ctx; /* UNUSED */
985 (void)indata; /* UNUSED */
986 (void)insize; /* UNUSED */
987 return (ARCHIVE_FAILED);
991 __archive_stub_sha384final(archive_sha384_ctx *ctx, void *md)
993 (void)ctx; /* UNUSED */
994 (void)md; /* UNUSED */
995 return (ARCHIVE_FAILED);
1000 /* SHA512 implementations */
1001 #if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1004 __archive_libc_sha512init(archive_sha512_ctx *ctx)
1007 return (ARCHIVE_OK);
1011 __archive_libc_sha512update(archive_sha512_ctx *ctx, const void *indata,
1014 SHA512_Update(ctx, indata, insize);
1015 return (ARCHIVE_OK);
1019 __archive_libc_sha512final(archive_sha512_ctx *ctx, void *md)
1021 SHA512_Final(md, ctx);
1022 return (ARCHIVE_OK);
1025 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1028 __archive_libc2_sha512init(archive_sha512_ctx *ctx)
1031 return (ARCHIVE_OK);
1035 __archive_libc2_sha512update(archive_sha512_ctx *ctx, const void *indata,
1038 SHA512Update(ctx, indata, insize);
1039 return (ARCHIVE_OK);
1043 __archive_libc2_sha512final(archive_sha512_ctx *ctx, void *md)
1045 SHA512Final(md, ctx);
1046 return (ARCHIVE_OK);
1049 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1052 __archive_libc3_sha512init(archive_sha512_ctx *ctx)
1055 return (ARCHIVE_OK);
1059 __archive_libc3_sha512update(archive_sha512_ctx *ctx, const void *indata,
1062 SHA512Update(ctx, indata, insize);
1063 return (ARCHIVE_OK);
1067 __archive_libc3_sha512final(archive_sha512_ctx *ctx, void *md)
1069 SHA512Final(md, ctx);
1070 return (ARCHIVE_OK);
1073 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1076 __archive_libmd_sha512init(archive_sha512_ctx *ctx)
1079 return (ARCHIVE_OK);
1083 __archive_libmd_sha512update(archive_sha512_ctx *ctx, const void *indata,
1086 SHA512_Update(ctx, indata, insize);
1087 return (ARCHIVE_OK);
1091 __archive_libmd_sha512final(archive_sha512_ctx *ctx, void *md)
1093 SHA512_Final(md, ctx);
1094 return (ARCHIVE_OK);
1097 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1100 __archive_libsystem_sha512init(archive_sha512_ctx *ctx)
1102 CC_SHA512_Init(ctx);
1103 return (ARCHIVE_OK);
1107 __archive_libsystem_sha512update(archive_sha512_ctx *ctx, const void *indata,
1110 CC_SHA512_Update(ctx, indata, insize);
1111 return (ARCHIVE_OK);
1115 __archive_libsystem_sha512final(archive_sha512_ctx *ctx, void *md)
1117 CC_SHA512_Final(md, ctx);
1118 return (ARCHIVE_OK);
1121 #elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1124 __archive_nettle_sha512init(archive_sha512_ctx *ctx)
1127 return (ARCHIVE_OK);
1131 __archive_nettle_sha512update(archive_sha512_ctx *ctx, const void *indata,
1134 sha512_update(ctx, insize, indata);
1135 return (ARCHIVE_OK);
1139 __archive_nettle_sha512final(archive_sha512_ctx *ctx, void *md)
1141 sha512_digest(ctx, SHA512_DIGEST_SIZE, md);
1142 return (ARCHIVE_OK);
1145 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1148 __archive_openssl_sha512init(archive_sha512_ctx *ctx)
1150 EVP_DigestInit(ctx, EVP_sha512());
1151 return (ARCHIVE_OK);
1155 __archive_openssl_sha512update(archive_sha512_ctx *ctx, const void *indata,
1158 EVP_DigestUpdate(ctx, indata, insize);
1159 return (ARCHIVE_OK);
1163 __archive_openssl_sha512final(archive_sha512_ctx *ctx, void *md)
1165 EVP_DigestFinal(ctx, md, NULL);
1166 return (ARCHIVE_OK);
1169 #elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1172 __archive_windowsapi_sha512init(archive_sha512_ctx *ctx)
1174 return (win_crypto_init(ctx, CALG_SHA_512));
1178 __archive_windowsapi_sha512update(archive_sha512_ctx *ctx, const void *indata,
1181 return (win_crypto_Update(ctx, indata, insize));
1185 __archive_windowsapi_sha512final(archive_sha512_ctx *ctx, void *md)
1187 return (win_crypto_Final(md, 64, ctx));
1193 __archive_stub_sha512init(archive_sha512_ctx *ctx)
1195 (void)ctx; /* UNUSED */
1196 return (ARCHIVE_FAILED);
1200 __archive_stub_sha512update(archive_sha512_ctx *ctx, const void *indata,
1203 (void)ctx; /* UNUSED */
1204 (void)indata; /* UNUSED */
1205 (void)insize; /* UNUSED */
1206 return (ARCHIVE_FAILED);
1210 __archive_stub_sha512final(archive_sha512_ctx *ctx, void *md)
1212 (void)ctx; /* UNUSED */
1213 (void)md; /* UNUSED */
1214 return (ARCHIVE_FAILED);
1219 /* NOTE: Crypto functions are set based on availability and by the following
1220 * order of preference.
1230 const struct archive_crypto __archive_crypto =
1233 #if defined(ARCHIVE_CRYPTO_MD5_LIBC)
1234 &__archive_libc_md5init,
1235 &__archive_libc_md5update,
1236 &__archive_libc_md5final,
1237 #elif defined(ARCHIVE_CRYPTO_MD5_LIBMD)
1238 &__archive_libmd_md5init,
1239 &__archive_libmd_md5update,
1240 &__archive_libmd_md5final,
1241 #elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM)
1242 &__archive_libsystem_md5init,
1243 &__archive_libsystem_md5update,
1244 &__archive_libsystem_md5final,
1245 #elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
1246 &__archive_nettle_md5init,
1247 &__archive_nettle_md5update,
1248 &__archive_nettle_md5final,
1249 #elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
1250 &__archive_openssl_md5init,
1251 &__archive_openssl_md5update,
1252 &__archive_openssl_md5final,
1253 #elif defined(ARCHIVE_CRYPTO_MD5_WIN)
1254 &__archive_windowsapi_md5init,
1255 &__archive_windowsapi_md5update,
1256 &__archive_windowsapi_md5final,
1257 #elif !defined(ARCHIVE_MD5_COMPILE_TEST)
1258 &__archive_stub_md5init,
1259 &__archive_stub_md5update,
1260 &__archive_stub_md5final,
1264 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
1265 &__archive_libc_ripemd160init,
1266 &__archive_libc_ripemd160update,
1267 &__archive_libc_ripemd160final,
1268 #elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
1269 &__archive_libmd_ripemd160init,
1270 &__archive_libmd_ripemd160update,
1271 &__archive_libmd_ripemd160final,
1272 #elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
1273 &__archive_nettle_ripemd160init,
1274 &__archive_nettle_ripemd160update,
1275 &__archive_nettle_ripemd160final,
1276 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
1277 &__archive_openssl_ripemd160init,
1278 &__archive_openssl_ripemd160update,
1279 &__archive_openssl_ripemd160final,
1280 #elif !defined(ARCHIVE_RMD160_COMPILE_TEST)
1281 &__archive_stub_ripemd160init,
1282 &__archive_stub_ripemd160update,
1283 &__archive_stub_ripemd160final,
1287 #if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
1288 &__archive_libc_sha1init,
1289 &__archive_libc_sha1update,
1290 &__archive_libc_sha1final,
1291 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
1292 &__archive_libmd_sha1init,
1293 &__archive_libmd_sha1update,
1294 &__archive_libmd_sha1final,
1295 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
1296 &__archive_libsystem_sha1init,
1297 &__archive_libsystem_sha1update,
1298 &__archive_libsystem_sha1final,
1299 #elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
1300 &__archive_nettle_sha1init,
1301 &__archive_nettle_sha1update,
1302 &__archive_nettle_sha1final,
1303 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
1304 &__archive_openssl_sha1init,
1305 &__archive_openssl_sha1update,
1306 &__archive_openssl_sha1final,
1307 #elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
1308 &__archive_windowsapi_sha1init,
1309 &__archive_windowsapi_sha1update,
1310 &__archive_windowsapi_sha1final,
1311 #elif !defined(ARCHIVE_SHA1_COMPILE_TEST)
1312 &__archive_stub_sha1init,
1313 &__archive_stub_sha1update,
1314 &__archive_stub_sha1final,
1318 #if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
1319 &__archive_libc_sha256init,
1320 &__archive_libc_sha256update,
1321 &__archive_libc_sha256final,
1322 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
1323 &__archive_libc2_sha256init,
1324 &__archive_libc2_sha256update,
1325 &__archive_libc2_sha256final,
1326 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
1327 &__archive_libc3_sha256init,
1328 &__archive_libc3_sha256update,
1329 &__archive_libc3_sha256final,
1330 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
1331 &__archive_libmd_sha256init,
1332 &__archive_libmd_sha256update,
1333 &__archive_libmd_sha256final,
1334 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
1335 &__archive_libsystem_sha256init,
1336 &__archive_libsystem_sha256update,
1337 &__archive_libsystem_sha256final,
1338 #elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
1339 &__archive_nettle_sha256init,
1340 &__archive_nettle_sha256update,
1341 &__archive_nettle_sha256final,
1342 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
1343 &__archive_openssl_sha256init,
1344 &__archive_openssl_sha256update,
1345 &__archive_openssl_sha256final,
1346 #elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
1347 &__archive_windowsapi_sha256init,
1348 &__archive_windowsapi_sha256update,
1349 &__archive_windowsapi_sha256final,
1350 #elif !defined(ARCHIVE_SHA256_COMPILE_TEST)
1351 &__archive_stub_sha256init,
1352 &__archive_stub_sha256update,
1353 &__archive_stub_sha256final,
1357 #if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
1358 &__archive_libc_sha384init,
1359 &__archive_libc_sha384update,
1360 &__archive_libc_sha384final,
1361 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
1362 &__archive_libc2_sha384init,
1363 &__archive_libc2_sha384update,
1364 &__archive_libc2_sha384final,
1365 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
1366 &__archive_libc3_sha384init,
1367 &__archive_libc3_sha384update,
1368 &__archive_libc3_sha384final,
1369 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
1370 &__archive_libsystem_sha384init,
1371 &__archive_libsystem_sha384update,
1372 &__archive_libsystem_sha384final,
1373 #elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
1374 &__archive_nettle_sha384init,
1375 &__archive_nettle_sha384update,
1376 &__archive_nettle_sha384final,
1377 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
1378 &__archive_openssl_sha384init,
1379 &__archive_openssl_sha384update,
1380 &__archive_openssl_sha384final,
1381 #elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
1382 &__archive_windowsapi_sha384init,
1383 &__archive_windowsapi_sha384update,
1384 &__archive_windowsapi_sha384final,
1385 #elif !defined(ARCHIVE_SHA384_COMPILE_TEST)
1386 &__archive_stub_sha384init,
1387 &__archive_stub_sha384update,
1388 &__archive_stub_sha384final,
1392 #if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1393 &__archive_libc_sha512init,
1394 &__archive_libc_sha512update,
1395 &__archive_libc_sha512final
1396 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1397 &__archive_libc2_sha512init,
1398 &__archive_libc2_sha512update,
1399 &__archive_libc2_sha512final
1400 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1401 &__archive_libc3_sha512init,
1402 &__archive_libc3_sha512update,
1403 &__archive_libc3_sha512final
1404 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1405 &__archive_libmd_sha512init,
1406 &__archive_libmd_sha512update,
1407 &__archive_libmd_sha512final
1408 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1409 &__archive_libsystem_sha512init,
1410 &__archive_libsystem_sha512update,
1411 &__archive_libsystem_sha512final
1412 #elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1413 &__archive_nettle_sha512init,
1414 &__archive_nettle_sha512update,
1415 &__archive_nettle_sha512final,
1416 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1417 &__archive_openssl_sha512init,
1418 &__archive_openssl_sha512update,
1419 &__archive_openssl_sha512final
1420 #elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1421 &__archive_windowsapi_sha512init,
1422 &__archive_windowsapi_sha512update,
1423 &__archive_windowsapi_sha512final
1424 #elif !defined(ARCHIVE_SHA512_COMPILE_TEST)
1425 &__archive_stub_sha512init,
1426 &__archive_stub_sha512update,
1427 &__archive_stub_sha512final