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 = 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.
1228 const struct archive_crypto __archive_crypto =
1231 #if defined(ARCHIVE_CRYPTO_MD5_LIBC)
1232 &__archive_libc_md5init,
1233 &__archive_libc_md5update,
1234 &__archive_libc_md5final,
1235 #elif defined(ARCHIVE_CRYPTO_MD5_LIBMD)
1236 &__archive_libmd_md5init,
1237 &__archive_libmd_md5update,
1238 &__archive_libmd_md5final,
1239 #elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM)
1240 &__archive_libsystem_md5init,
1241 &__archive_libsystem_md5update,
1242 &__archive_libsystem_md5final,
1243 #elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
1244 &__archive_nettle_md5init,
1245 &__archive_nettle_md5update,
1246 &__archive_nettle_md5final,
1247 #elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
1248 &__archive_openssl_md5init,
1249 &__archive_openssl_md5update,
1250 &__archive_openssl_md5final,
1251 #elif defined(ARCHIVE_CRYPTO_MD5_WIN)
1252 &__archive_windowsapi_md5init,
1253 &__archive_windowsapi_md5update,
1254 &__archive_windowsapi_md5final,
1255 #elif !defined(ARCHIVE_MD5_COMPILE_TEST)
1256 &__archive_stub_md5init,
1257 &__archive_stub_md5update,
1258 &__archive_stub_md5final,
1262 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
1263 &__archive_libc_ripemd160init,
1264 &__archive_libc_ripemd160update,
1265 &__archive_libc_ripemd160final,
1266 #elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
1267 &__archive_libmd_ripemd160init,
1268 &__archive_libmd_ripemd160update,
1269 &__archive_libmd_ripemd160final,
1270 #elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
1271 &__archive_nettle_ripemd160init,
1272 &__archive_nettle_ripemd160update,
1273 &__archive_nettle_ripemd160final,
1274 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
1275 &__archive_openssl_ripemd160init,
1276 &__archive_openssl_ripemd160update,
1277 &__archive_openssl_ripemd160final,
1278 #elif !defined(ARCHIVE_RMD160_COMPILE_TEST)
1279 &__archive_stub_ripemd160init,
1280 &__archive_stub_ripemd160update,
1281 &__archive_stub_ripemd160final,
1285 #if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
1286 &__archive_libc_sha1init,
1287 &__archive_libc_sha1update,
1288 &__archive_libc_sha1final,
1289 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
1290 &__archive_libmd_sha1init,
1291 &__archive_libmd_sha1update,
1292 &__archive_libmd_sha1final,
1293 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
1294 &__archive_libsystem_sha1init,
1295 &__archive_libsystem_sha1update,
1296 &__archive_libsystem_sha1final,
1297 #elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
1298 &__archive_nettle_sha1init,
1299 &__archive_nettle_sha1update,
1300 &__archive_nettle_sha1final,
1301 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
1302 &__archive_openssl_sha1init,
1303 &__archive_openssl_sha1update,
1304 &__archive_openssl_sha1final,
1305 #elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
1306 &__archive_windowsapi_sha1init,
1307 &__archive_windowsapi_sha1update,
1308 &__archive_windowsapi_sha1final,
1309 #elif !defined(ARCHIVE_SHA1_COMPILE_TEST)
1310 &__archive_stub_sha1init,
1311 &__archive_stub_sha1update,
1312 &__archive_stub_sha1final,
1316 #if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
1317 &__archive_libc_sha256init,
1318 &__archive_libc_sha256update,
1319 &__archive_libc_sha256final,
1320 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
1321 &__archive_libc2_sha256init,
1322 &__archive_libc2_sha256update,
1323 &__archive_libc2_sha256final,
1324 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
1325 &__archive_libc3_sha256init,
1326 &__archive_libc3_sha256update,
1327 &__archive_libc3_sha256final,
1328 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
1329 &__archive_libmd_sha256init,
1330 &__archive_libmd_sha256update,
1331 &__archive_libmd_sha256final,
1332 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
1333 &__archive_libsystem_sha256init,
1334 &__archive_libsystem_sha256update,
1335 &__archive_libsystem_sha256final,
1336 #elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
1337 &__archive_nettle_sha256init,
1338 &__archive_nettle_sha256update,
1339 &__archive_nettle_sha256final,
1340 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
1341 &__archive_openssl_sha256init,
1342 &__archive_openssl_sha256update,
1343 &__archive_openssl_sha256final,
1344 #elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
1345 &__archive_windowsapi_sha256init,
1346 &__archive_windowsapi_sha256update,
1347 &__archive_windowsapi_sha256final,
1348 #elif !defined(ARCHIVE_SHA256_COMPILE_TEST)
1349 &__archive_stub_sha256init,
1350 &__archive_stub_sha256update,
1351 &__archive_stub_sha256final,
1355 #if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
1356 &__archive_libc_sha384init,
1357 &__archive_libc_sha384update,
1358 &__archive_libc_sha384final,
1359 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
1360 &__archive_libc2_sha384init,
1361 &__archive_libc2_sha384update,
1362 &__archive_libc2_sha384final,
1363 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
1364 &__archive_libc3_sha384init,
1365 &__archive_libc3_sha384update,
1366 &__archive_libc3_sha384final,
1367 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
1368 &__archive_libsystem_sha384init,
1369 &__archive_libsystem_sha384update,
1370 &__archive_libsystem_sha384final,
1371 #elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
1372 &__archive_nettle_sha384init,
1373 &__archive_nettle_sha384update,
1374 &__archive_nettle_sha384final,
1375 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
1376 &__archive_openssl_sha384init,
1377 &__archive_openssl_sha384update,
1378 &__archive_openssl_sha384final,
1379 #elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
1380 &__archive_windowsapi_sha384init,
1381 &__archive_windowsapi_sha384update,
1382 &__archive_windowsapi_sha384final,
1383 #elif !defined(ARCHIVE_SHA384_COMPILE_TEST)
1384 &__archive_stub_sha384init,
1385 &__archive_stub_sha384update,
1386 &__archive_stub_sha384final,
1390 #if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1391 &__archive_libc_sha512init,
1392 &__archive_libc_sha512update,
1393 &__archive_libc_sha512final
1394 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1395 &__archive_libc2_sha512init,
1396 &__archive_libc2_sha512update,
1397 &__archive_libc2_sha512final
1398 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1399 &__archive_libc3_sha512init,
1400 &__archive_libc3_sha512update,
1401 &__archive_libc3_sha512final
1402 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1403 &__archive_libmd_sha512init,
1404 &__archive_libmd_sha512update,
1405 &__archive_libmd_sha512final
1406 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1407 &__archive_libsystem_sha512init,
1408 &__archive_libsystem_sha512update,
1409 &__archive_libsystem_sha512final
1410 #elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1411 &__archive_nettle_sha512init,
1412 &__archive_nettle_sha512update,
1413 &__archive_nettle_sha512final,
1414 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1415 &__archive_openssl_sha512init,
1416 &__archive_openssl_sha512update,
1417 &__archive_openssl_sha512final
1418 #elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1419 &__archive_windowsapi_sha512init,
1420 &__archive_windowsapi_sha512update,
1421 &__archive_windowsapi_sha512final
1422 #elif !defined(ARCHIVE_SHA512_COMPILE_TEST)
1423 &__archive_stub_sha512init,
1424 &__archive_stub_sha512update,
1425 &__archive_stub_sha512final