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_md5init(archive_md5_ctx *ctx)
119 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
122 MD5Update(ctx, indata, insize);
127 __archive_md5final(archive_md5_ctx *ctx, void *md)
133 #elif defined(ARCHIVE_CRYPTO_MD5_LIBMD)
136 __archive_md5init(archive_md5_ctx *ctx)
143 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
146 MD5Update(ctx, indata, insize);
151 __archive_md5final(archive_md5_ctx *ctx, void *md)
157 #elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM)
160 __archive_md5init(archive_md5_ctx *ctx)
167 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
170 CC_MD5_Update(ctx, indata, insize);
175 __archive_md5final(archive_md5_ctx *ctx, void *md)
177 CC_MD5_Final(md, ctx);
181 #elif defined(ARCHIVE_CRYPTO_MD5_MBEDTLS)
184 __archive_md5init(archive_md5_ctx *ctx)
186 mbedtls_md5_init(ctx);
187 if (mbedtls_md5_starts_ret(ctx) == 0)
190 return (ARCHIVE_FATAL);
194 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
197 if (mbedtls_md5_update_ret(ctx, indata, insize) == 0)
200 return (ARCHIVE_FATAL);
204 __archive_md5final(archive_md5_ctx *ctx, void *md)
206 if (mbedtls_md5_finish_ret(ctx, md) == 0) {
207 mbedtls_md5_free(ctx);
210 mbedtls_md5_free(ctx);
211 return (ARCHIVE_FATAL);
215 #elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
218 __archive_md5init(archive_md5_ctx *ctx)
225 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
228 md5_update(ctx, insize, indata);
233 __archive_md5final(archive_md5_ctx *ctx, void *md)
235 md5_digest(ctx, MD5_DIGEST_SIZE, md);
239 #elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
242 __archive_md5init(archive_md5_ctx *ctx)
244 if ((*ctx = EVP_MD_CTX_new()) == NULL)
245 return (ARCHIVE_FAILED);
246 if (!EVP_DigestInit(*ctx, EVP_md5()))
247 return (ARCHIVE_FAILED);
252 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
255 EVP_DigestUpdate(*ctx, indata, insize);
260 __archive_md5final(archive_md5_ctx *ctx, void *md)
262 /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
263 * this is meant to cope with that. Real fix is probably to fix
264 * archive_write_set_format_xar.c
267 EVP_DigestFinal(*ctx, md, NULL);
268 EVP_MD_CTX_free(*ctx);
274 #elif defined(ARCHIVE_CRYPTO_MD5_WIN)
277 __archive_md5init(archive_md5_ctx *ctx)
279 return (win_crypto_init(ctx, CALG_MD5));
283 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
286 return (win_crypto_Update(ctx, indata, insize));
290 __archive_md5final(archive_md5_ctx *ctx, void *md)
292 return (win_crypto_Final(md, 16, ctx));
298 __archive_md5init(archive_md5_ctx *ctx)
300 (void)ctx; /* UNUSED */
301 return (ARCHIVE_FAILED);
305 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
308 (void)ctx; /* UNUSED */
309 (void)indata; /* UNUSED */
310 (void)insize; /* UNUSED */
311 return (ARCHIVE_FAILED);
315 __archive_md5final(archive_md5_ctx *ctx, void *md)
317 (void)ctx; /* UNUSED */
318 (void)md; /* UNUSED */
319 return (ARCHIVE_FAILED);
324 /* RIPEMD160 implementations */
325 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
328 __archive_ripemd160init(archive_rmd160_ctx *ctx)
335 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
338 RMD160Update(ctx, indata, insize);
343 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
345 RMD160Final(md, ctx);
349 #elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
352 __archive_ripemd160init(archive_rmd160_ctx *ctx)
359 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
362 RIPEMD160_Update(ctx, indata, insize);
367 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
369 RIPEMD160_Final(md, ctx);
373 #elif defined(ARCHIVE_CRYPTO_RMD160_MBEDTLS)
376 __archive_ripemd160init(archive_rmd160_ctx *ctx)
378 mbedtls_ripemd160_init(ctx);
379 if (mbedtls_ripemd160_starts_ret(ctx) == 0)
382 return (ARCHIVE_FATAL);
386 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
389 if (mbedtls_ripemd160_update_ret(ctx, indata, insize) == 0)
392 return (ARCHIVE_FATAL);
396 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
398 if (mbedtls_ripemd160_finish_ret(ctx, md) == 0) {
399 mbedtls_ripemd160_free(ctx);
402 mbedtls_ripemd160_free(ctx);
403 return (ARCHIVE_FATAL);
407 #elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
410 __archive_ripemd160init(archive_rmd160_ctx *ctx)
417 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
420 ripemd160_update(ctx, insize, indata);
425 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
427 ripemd160_digest(ctx, RIPEMD160_DIGEST_SIZE, md);
431 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
434 __archive_ripemd160init(archive_rmd160_ctx *ctx)
436 if ((*ctx = EVP_MD_CTX_new()) == NULL)
437 return (ARCHIVE_FAILED);
438 if (!EVP_DigestInit(*ctx, EVP_ripemd160()))
439 return (ARCHIVE_FAILED);
444 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
447 EVP_DigestUpdate(*ctx, indata, insize);
452 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
455 EVP_DigestFinal(*ctx, md, NULL);
456 EVP_MD_CTX_free(*ctx);
465 __archive_ripemd160init(archive_rmd160_ctx *ctx)
467 (void)ctx; /* UNUSED */
468 return (ARCHIVE_FAILED);
472 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
475 (void)ctx; /* UNUSED */
476 (void)indata; /* UNUSED */
477 (void)insize; /* UNUSED */
478 return (ARCHIVE_FAILED);
482 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
484 (void)ctx; /* UNUSED */
485 (void)md; /* UNUSED */
486 return (ARCHIVE_FAILED);
491 /* SHA1 implementations */
492 #if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
495 __archive_sha1init(archive_sha1_ctx *ctx)
502 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
505 SHA1Update(ctx, indata, insize);
510 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
516 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
519 __archive_sha1init(archive_sha1_ctx *ctx)
526 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
529 SHA1_Update(ctx, indata, insize);
534 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
540 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
543 __archive_sha1init(archive_sha1_ctx *ctx)
550 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
553 CC_SHA1_Update(ctx, indata, insize);
558 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
560 CC_SHA1_Final(md, ctx);
564 #elif defined(ARCHIVE_CRYPTO_SHA1_MBEDTLS)
567 __archive_sha1init(archive_sha1_ctx *ctx)
569 mbedtls_sha1_init(ctx);
570 if (mbedtls_sha1_starts_ret(ctx) == 0)
573 return (ARCHIVE_FATAL);
577 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
580 if (mbedtls_sha1_update_ret(ctx, indata, insize) == 0)
583 return (ARCHIVE_FATAL);
587 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
589 if (mbedtls_sha1_finish_ret(ctx, md) == 0) {
590 mbedtls_sha1_free(ctx);
593 mbedtls_sha1_free(ctx);
594 return (ARCHIVE_FATAL);
598 #elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
601 __archive_sha1init(archive_sha1_ctx *ctx)
608 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
611 sha1_update(ctx, insize, indata);
616 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
618 sha1_digest(ctx, SHA1_DIGEST_SIZE, md);
622 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
625 __archive_sha1init(archive_sha1_ctx *ctx)
627 if ((*ctx = EVP_MD_CTX_new()) == NULL)
628 return (ARCHIVE_FAILED);
629 if (!EVP_DigestInit(*ctx, EVP_sha1()))
630 return (ARCHIVE_FAILED);
635 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
638 EVP_DigestUpdate(*ctx, indata, insize);
643 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
645 /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
646 * this is meant to cope with that. Real fix is probably to fix
647 * archive_write_set_format_xar.c
650 EVP_DigestFinal(*ctx, md, NULL);
651 EVP_MD_CTX_free(*ctx);
657 #elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
660 __archive_sha1init(archive_sha1_ctx *ctx)
662 return (win_crypto_init(ctx, CALG_SHA1));
666 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
669 return (win_crypto_Update(ctx, indata, insize));
673 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
675 return (win_crypto_Final(md, 20, ctx));
681 __archive_sha1init(archive_sha1_ctx *ctx)
683 (void)ctx; /* UNUSED */
684 return (ARCHIVE_FAILED);
688 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
691 (void)ctx; /* UNUSED */
692 (void)indata; /* UNUSED */
693 (void)insize; /* UNUSED */
694 return (ARCHIVE_FAILED);
698 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
700 (void)ctx; /* UNUSED */
701 (void)md; /* UNUSED */
702 return (ARCHIVE_FAILED);
707 /* SHA256 implementations */
708 #if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
711 __archive_sha256init(archive_sha256_ctx *ctx)
718 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
721 SHA256_Update(ctx, indata, insize);
726 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
728 SHA256_Final(md, ctx);
732 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
735 __archive_sha256init(archive_sha256_ctx *ctx)
742 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
745 SHA256Update(ctx, indata, insize);
750 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
752 SHA256Final(md, ctx);
756 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
759 __archive_sha256init(archive_sha256_ctx *ctx)
766 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
769 SHA256Update(ctx, indata, insize);
774 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
776 SHA256Final(md, ctx);
780 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
783 __archive_sha256init(archive_sha256_ctx *ctx)
790 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
793 SHA256_Update(ctx, indata, insize);
798 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
800 SHA256_Final(md, ctx);
804 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
807 __archive_sha256init(archive_sha256_ctx *ctx)
814 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
817 CC_SHA256_Update(ctx, indata, insize);
822 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
824 CC_SHA256_Final(md, ctx);
828 #elif defined(ARCHIVE_CRYPTO_SHA256_MBEDTLS)
831 __archive_sha256init(archive_sha256_ctx *ctx)
833 mbedtls_sha256_init(ctx);
834 if (mbedtls_sha256_starts_ret(ctx, 0) == 0)
837 return (ARCHIVE_FATAL);
841 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
844 if (mbedtls_sha256_update_ret(ctx, indata, insize) == 0)
847 return (ARCHIVE_FATAL);
851 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
853 if (mbedtls_sha256_finish_ret(ctx, md) == 0) {
854 mbedtls_sha256_free(ctx);
857 mbedtls_sha256_free(ctx);
858 return (ARCHIVE_FATAL);
862 #elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
865 __archive_sha256init(archive_sha256_ctx *ctx)
872 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
875 sha256_update(ctx, insize, indata);
880 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
882 sha256_digest(ctx, SHA256_DIGEST_SIZE, md);
886 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
889 __archive_sha256init(archive_sha256_ctx *ctx)
891 if ((*ctx = EVP_MD_CTX_new()) == NULL)
892 return (ARCHIVE_FAILED);
893 if (!EVP_DigestInit(*ctx, EVP_sha256()))
894 return (ARCHIVE_FAILED);
899 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
902 EVP_DigestUpdate(*ctx, indata, insize);
907 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
910 EVP_DigestFinal(*ctx, md, NULL);
911 EVP_MD_CTX_free(*ctx);
917 #elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
920 __archive_sha256init(archive_sha256_ctx *ctx)
922 return (win_crypto_init(ctx, CALG_SHA_256));
926 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
929 return (win_crypto_Update(ctx, indata, insize));
933 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
935 return (win_crypto_Final(md, 32, ctx));
941 __archive_sha256init(archive_sha256_ctx *ctx)
943 (void)ctx; /* UNUSED */
944 return (ARCHIVE_FAILED);
948 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
951 (void)ctx; /* UNUSED */
952 (void)indata; /* UNUSED */
953 (void)insize; /* UNUSED */
954 return (ARCHIVE_FAILED);
958 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
960 (void)ctx; /* UNUSED */
961 (void)md; /* UNUSED */
962 return (ARCHIVE_FAILED);
967 /* SHA384 implementations */
968 #if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
971 __archive_sha384init(archive_sha384_ctx *ctx)
978 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
981 SHA384_Update(ctx, indata, insize);
986 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
988 SHA384_Final(md, ctx);
992 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
995 __archive_sha384init(archive_sha384_ctx *ctx)
1002 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1005 SHA384Update(ctx, indata, insize);
1006 return (ARCHIVE_OK);
1010 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1012 SHA384Final(md, ctx);
1013 return (ARCHIVE_OK);
1016 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
1019 __archive_sha384init(archive_sha384_ctx *ctx)
1022 return (ARCHIVE_OK);
1026 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1029 SHA384Update(ctx, indata, insize);
1030 return (ARCHIVE_OK);
1034 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1036 SHA384Final(md, ctx);
1037 return (ARCHIVE_OK);
1040 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
1043 __archive_sha384init(archive_sha384_ctx *ctx)
1045 CC_SHA384_Init(ctx);
1046 return (ARCHIVE_OK);
1050 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1053 CC_SHA384_Update(ctx, indata, insize);
1054 return (ARCHIVE_OK);
1058 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1060 CC_SHA384_Final(md, ctx);
1061 return (ARCHIVE_OK);
1064 #elif defined(ARCHIVE_CRYPTO_SHA384_MBEDTLS)
1067 __archive_sha384init(archive_sha384_ctx *ctx)
1069 mbedtls_sha512_init(ctx);
1070 if (mbedtls_sha512_starts_ret(ctx, 1) == 0)
1071 return (ARCHIVE_OK);
1073 return (ARCHIVE_FATAL);
1077 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1080 if (mbedtls_sha512_update_ret(ctx, indata, insize) == 0)
1081 return (ARCHIVE_OK);
1083 return (ARCHIVE_FATAL);
1087 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1089 if (mbedtls_sha512_finish_ret(ctx, md) == 0) {
1090 mbedtls_sha512_free(ctx);
1091 return (ARCHIVE_OK);
1093 mbedtls_sha512_free(ctx);
1094 return (ARCHIVE_FATAL);
1098 #elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
1101 __archive_sha384init(archive_sha384_ctx *ctx)
1104 return (ARCHIVE_OK);
1108 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1111 sha384_update(ctx, insize, indata);
1112 return (ARCHIVE_OK);
1116 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1118 sha384_digest(ctx, SHA384_DIGEST_SIZE, md);
1119 return (ARCHIVE_OK);
1122 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
1125 __archive_sha384init(archive_sha384_ctx *ctx)
1127 if ((*ctx = EVP_MD_CTX_new()) == NULL)
1128 return (ARCHIVE_FAILED);
1129 if (!EVP_DigestInit(*ctx, EVP_sha384()))
1130 return (ARCHIVE_FAILED);
1131 return (ARCHIVE_OK);
1135 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1138 EVP_DigestUpdate(*ctx, indata, insize);
1139 return (ARCHIVE_OK);
1143 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1146 EVP_DigestFinal(*ctx, md, NULL);
1147 EVP_MD_CTX_free(*ctx);
1150 return (ARCHIVE_OK);
1153 #elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
1156 __archive_sha384init(archive_sha384_ctx *ctx)
1158 return (win_crypto_init(ctx, CALG_SHA_384));
1162 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1165 return (win_crypto_Update(ctx, indata, insize));
1169 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1171 return (win_crypto_Final(md, 48, ctx));
1177 __archive_sha384init(archive_sha384_ctx *ctx)
1179 (void)ctx; /* UNUSED */
1180 return (ARCHIVE_FAILED);
1184 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1187 (void)ctx; /* UNUSED */
1188 (void)indata; /* UNUSED */
1189 (void)insize; /* UNUSED */
1190 return (ARCHIVE_FAILED);
1194 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1196 (void)ctx; /* UNUSED */
1197 (void)md; /* UNUSED */
1198 return (ARCHIVE_FAILED);
1203 /* SHA512 implementations */
1204 #if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1207 __archive_sha512init(archive_sha512_ctx *ctx)
1210 return (ARCHIVE_OK);
1214 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1217 SHA512_Update(ctx, indata, insize);
1218 return (ARCHIVE_OK);
1222 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1224 SHA512_Final(md, ctx);
1225 return (ARCHIVE_OK);
1228 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1231 __archive_sha512init(archive_sha512_ctx *ctx)
1234 return (ARCHIVE_OK);
1238 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1241 SHA512Update(ctx, indata, insize);
1242 return (ARCHIVE_OK);
1246 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1248 SHA512Final(md, ctx);
1249 return (ARCHIVE_OK);
1252 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1255 __archive_sha512init(archive_sha512_ctx *ctx)
1258 return (ARCHIVE_OK);
1262 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1265 SHA512Update(ctx, indata, insize);
1266 return (ARCHIVE_OK);
1270 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1272 SHA512Final(md, ctx);
1273 return (ARCHIVE_OK);
1276 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1279 __archive_sha512init(archive_sha512_ctx *ctx)
1282 return (ARCHIVE_OK);
1286 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1289 SHA512_Update(ctx, indata, insize);
1290 return (ARCHIVE_OK);
1294 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1296 SHA512_Final(md, ctx);
1297 return (ARCHIVE_OK);
1300 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1303 __archive_sha512init(archive_sha512_ctx *ctx)
1305 CC_SHA512_Init(ctx);
1306 return (ARCHIVE_OK);
1310 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1313 CC_SHA512_Update(ctx, indata, insize);
1314 return (ARCHIVE_OK);
1318 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1320 CC_SHA512_Final(md, ctx);
1321 return (ARCHIVE_OK);
1324 #elif defined(ARCHIVE_CRYPTO_SHA512_MBEDTLS)
1327 __archive_sha512init(archive_sha512_ctx *ctx)
1329 mbedtls_sha512_init(ctx);
1330 if (mbedtls_sha512_starts_ret(ctx, 0) == 0)
1331 return (ARCHIVE_OK);
1333 return (ARCHIVE_FATAL);
1337 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1340 if (mbedtls_sha512_update_ret(ctx, indata, insize) == 0)
1341 return (ARCHIVE_OK);
1343 return (ARCHIVE_FATAL);
1347 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1349 if (mbedtls_sha512_finish_ret(ctx, md) == 0) {
1350 mbedtls_sha512_free(ctx);
1351 return (ARCHIVE_OK);
1353 mbedtls_sha512_free(ctx);
1354 return (ARCHIVE_FATAL);
1358 #elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1361 __archive_sha512init(archive_sha512_ctx *ctx)
1364 return (ARCHIVE_OK);
1368 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1371 sha512_update(ctx, insize, indata);
1372 return (ARCHIVE_OK);
1376 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1378 sha512_digest(ctx, SHA512_DIGEST_SIZE, md);
1379 return (ARCHIVE_OK);
1382 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1385 __archive_sha512init(archive_sha512_ctx *ctx)
1387 if ((*ctx = EVP_MD_CTX_new()) == NULL)
1388 return (ARCHIVE_FAILED);
1389 if (!EVP_DigestInit(*ctx, EVP_sha512()))
1390 return (ARCHIVE_FAILED);
1391 return (ARCHIVE_OK);
1395 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1398 EVP_DigestUpdate(*ctx, indata, insize);
1399 return (ARCHIVE_OK);
1403 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1406 EVP_DigestFinal(*ctx, md, NULL);
1407 EVP_MD_CTX_free(*ctx);
1410 return (ARCHIVE_OK);
1413 #elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1416 __archive_sha512init(archive_sha512_ctx *ctx)
1418 return (win_crypto_init(ctx, CALG_SHA_512));
1422 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1425 return (win_crypto_Update(ctx, indata, insize));
1429 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1431 return (win_crypto_Final(md, 64, ctx));
1437 __archive_sha512init(archive_sha512_ctx *ctx)
1439 (void)ctx; /* UNUSED */
1440 return (ARCHIVE_FAILED);
1444 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1447 (void)ctx; /* UNUSED */
1448 (void)indata; /* UNUSED */
1449 (void)insize; /* UNUSED */
1450 return (ARCHIVE_FAILED);
1454 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1456 (void)ctx; /* UNUSED */
1457 (void)md; /* UNUSED */
1458 return (ARCHIVE_FAILED);
1463 /* NOTE: Message Digest functions are set based on availability and by the
1464 * following order of preference.
1474 const struct archive_digest __archive_digest =
1478 &__archive_md5update,
1479 &__archive_md5final,
1482 &__archive_ripemd160init,
1483 &__archive_ripemd160update,
1484 &__archive_ripemd160final,
1487 &__archive_sha1init,
1488 &__archive_sha1update,
1489 &__archive_sha1final,
1492 &__archive_sha256init,
1493 &__archive_sha256update,
1494 &__archive_sha256final,
1497 &__archive_sha384init,
1498 &__archive_sha384update,
1499 &__archive_sha384final,
1502 &__archive_sha512init,
1503 &__archive_sha512update,
1504 &__archive_sha512final