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 EVP_DigestInit(*ctx, EVP_md5());
251 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
254 EVP_DigestUpdate(*ctx, indata, insize);
259 __archive_md5final(archive_md5_ctx *ctx, void *md)
261 /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
262 * this is meant to cope with that. Real fix is probably to fix
263 * archive_write_set_format_xar.c
266 EVP_DigestFinal(*ctx, md, NULL);
267 EVP_MD_CTX_free(*ctx);
273 #elif defined(ARCHIVE_CRYPTO_MD5_WIN)
276 __archive_md5init(archive_md5_ctx *ctx)
278 return (win_crypto_init(ctx, CALG_MD5));
282 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
285 return (win_crypto_Update(ctx, indata, insize));
289 __archive_md5final(archive_md5_ctx *ctx, void *md)
291 return (win_crypto_Final(md, 16, ctx));
297 __archive_md5init(archive_md5_ctx *ctx)
299 (void)ctx; /* UNUSED */
300 return (ARCHIVE_FAILED);
304 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
307 (void)ctx; /* UNUSED */
308 (void)indata; /* UNUSED */
309 (void)insize; /* UNUSED */
310 return (ARCHIVE_FAILED);
314 __archive_md5final(archive_md5_ctx *ctx, void *md)
316 (void)ctx; /* UNUSED */
317 (void)md; /* UNUSED */
318 return (ARCHIVE_FAILED);
323 /* RIPEMD160 implementations */
324 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
327 __archive_ripemd160init(archive_rmd160_ctx *ctx)
334 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
337 RMD160Update(ctx, indata, insize);
342 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
344 RMD160Final(md, ctx);
348 #elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
351 __archive_ripemd160init(archive_rmd160_ctx *ctx)
358 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
361 RIPEMD160_Update(ctx, indata, insize);
366 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
368 RIPEMD160_Final(md, ctx);
372 #elif defined(ARCHIVE_CRYPTO_RMD160_MBEDTLS)
375 __archive_ripemd160init(archive_rmd160_ctx *ctx)
377 mbedtls_ripemd160_init(ctx);
378 if (mbedtls_ripemd160_starts_ret(ctx) == 0)
381 return (ARCHIVE_FATAL);
385 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
388 if (mbedtls_ripemd160_update_ret(ctx, indata, insize) == 0)
391 return (ARCHIVE_FATAL);
395 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
397 if (mbedtls_ripemd160_finish_ret(ctx, md) == 0) {
398 mbedtls_ripemd160_free(ctx);
401 mbedtls_ripemd160_free(ctx);
402 return (ARCHIVE_FATAL);
406 #elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
409 __archive_ripemd160init(archive_rmd160_ctx *ctx)
416 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
419 ripemd160_update(ctx, insize, indata);
424 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
426 ripemd160_digest(ctx, RIPEMD160_DIGEST_SIZE, md);
430 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
433 __archive_ripemd160init(archive_rmd160_ctx *ctx)
435 if ((*ctx = EVP_MD_CTX_new()) == NULL)
436 return (ARCHIVE_FAILED);
437 EVP_DigestInit(*ctx, EVP_ripemd160());
442 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
445 EVP_DigestUpdate(*ctx, indata, insize);
450 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
453 EVP_DigestFinal(*ctx, md, NULL);
454 EVP_MD_CTX_free(*ctx);
463 __archive_ripemd160init(archive_rmd160_ctx *ctx)
465 (void)ctx; /* UNUSED */
466 return (ARCHIVE_FAILED);
470 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
473 (void)ctx; /* UNUSED */
474 (void)indata; /* UNUSED */
475 (void)insize; /* UNUSED */
476 return (ARCHIVE_FAILED);
480 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
482 (void)ctx; /* UNUSED */
483 (void)md; /* UNUSED */
484 return (ARCHIVE_FAILED);
489 /* SHA1 implementations */
490 #if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
493 __archive_sha1init(archive_sha1_ctx *ctx)
500 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
503 SHA1Update(ctx, indata, insize);
508 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
514 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
517 __archive_sha1init(archive_sha1_ctx *ctx)
524 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
527 SHA1_Update(ctx, indata, insize);
532 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
538 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
541 __archive_sha1init(archive_sha1_ctx *ctx)
548 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
551 CC_SHA1_Update(ctx, indata, insize);
556 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
558 CC_SHA1_Final(md, ctx);
562 #elif defined(ARCHIVE_CRYPTO_SHA1_MBEDTLS)
565 __archive_sha1init(archive_sha1_ctx *ctx)
567 mbedtls_sha1_init(ctx);
568 if (mbedtls_sha1_starts_ret(ctx) == 0)
571 return (ARCHIVE_FATAL);
575 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
578 if (mbedtls_sha1_update_ret(ctx, indata, insize) == 0)
581 return (ARCHIVE_FATAL);
585 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
587 if (mbedtls_sha1_finish_ret(ctx, md) == 0) {
588 mbedtls_sha1_free(ctx);
591 mbedtls_sha1_free(ctx);
592 return (ARCHIVE_FATAL);
596 #elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
599 __archive_sha1init(archive_sha1_ctx *ctx)
606 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
609 sha1_update(ctx, insize, indata);
614 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
616 sha1_digest(ctx, SHA1_DIGEST_SIZE, md);
620 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
623 __archive_sha1init(archive_sha1_ctx *ctx)
625 if ((*ctx = EVP_MD_CTX_new()) == NULL)
626 return (ARCHIVE_FAILED);
627 EVP_DigestInit(*ctx, EVP_sha1());
632 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
635 EVP_DigestUpdate(*ctx, indata, insize);
640 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
642 /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
643 * this is meant to cope with that. Real fix is probably to fix
644 * archive_write_set_format_xar.c
647 EVP_DigestFinal(*ctx, md, NULL);
648 EVP_MD_CTX_free(*ctx);
654 #elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
657 __archive_sha1init(archive_sha1_ctx *ctx)
659 return (win_crypto_init(ctx, CALG_SHA1));
663 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
666 return (win_crypto_Update(ctx, indata, insize));
670 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
672 return (win_crypto_Final(md, 20, ctx));
678 __archive_sha1init(archive_sha1_ctx *ctx)
680 (void)ctx; /* UNUSED */
681 return (ARCHIVE_FAILED);
685 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
688 (void)ctx; /* UNUSED */
689 (void)indata; /* UNUSED */
690 (void)insize; /* UNUSED */
691 return (ARCHIVE_FAILED);
695 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
697 (void)ctx; /* UNUSED */
698 (void)md; /* UNUSED */
699 return (ARCHIVE_FAILED);
704 /* SHA256 implementations */
705 #if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
708 __archive_sha256init(archive_sha256_ctx *ctx)
715 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
718 SHA256_Update(ctx, indata, insize);
723 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
725 SHA256_Final(md, ctx);
729 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
732 __archive_sha256init(archive_sha256_ctx *ctx)
739 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
742 SHA256Update(ctx, indata, insize);
747 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
749 SHA256Final(md, ctx);
753 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
756 __archive_sha256init(archive_sha256_ctx *ctx)
763 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
766 SHA256Update(ctx, indata, insize);
771 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
773 SHA256Final(md, ctx);
777 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
780 __archive_sha256init(archive_sha256_ctx *ctx)
787 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
790 SHA256_Update(ctx, indata, insize);
795 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
797 SHA256_Final(md, ctx);
801 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
804 __archive_sha256init(archive_sha256_ctx *ctx)
811 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
814 CC_SHA256_Update(ctx, indata, insize);
819 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
821 CC_SHA256_Final(md, ctx);
825 #elif defined(ARCHIVE_CRYPTO_SHA256_MBEDTLS)
828 __archive_sha256init(archive_sha256_ctx *ctx)
830 mbedtls_sha256_init(ctx);
831 if (mbedtls_sha256_starts_ret(ctx, 0) == 0)
834 return (ARCHIVE_FATAL);
838 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
841 if (mbedtls_sha256_update_ret(ctx, indata, insize) == 0)
844 return (ARCHIVE_FATAL);
848 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
850 if (mbedtls_sha256_finish_ret(ctx, md) == 0) {
851 mbedtls_sha256_free(ctx);
854 mbedtls_sha256_free(ctx);
855 return (ARCHIVE_FATAL);
859 #elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
862 __archive_sha256init(archive_sha256_ctx *ctx)
869 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
872 sha256_update(ctx, insize, indata);
877 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
879 sha256_digest(ctx, SHA256_DIGEST_SIZE, md);
883 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
886 __archive_sha256init(archive_sha256_ctx *ctx)
888 if ((*ctx = EVP_MD_CTX_new()) == NULL)
889 return (ARCHIVE_FAILED);
890 EVP_DigestInit(*ctx, EVP_sha256());
895 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
898 EVP_DigestUpdate(*ctx, indata, insize);
903 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
906 EVP_DigestFinal(*ctx, md, NULL);
907 EVP_MD_CTX_free(*ctx);
913 #elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
916 __archive_sha256init(archive_sha256_ctx *ctx)
918 return (win_crypto_init(ctx, CALG_SHA_256));
922 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
925 return (win_crypto_Update(ctx, indata, insize));
929 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
931 return (win_crypto_Final(md, 32, ctx));
937 __archive_sha256init(archive_sha256_ctx *ctx)
939 (void)ctx; /* UNUSED */
940 return (ARCHIVE_FAILED);
944 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
947 (void)ctx; /* UNUSED */
948 (void)indata; /* UNUSED */
949 (void)insize; /* UNUSED */
950 return (ARCHIVE_FAILED);
954 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
956 (void)ctx; /* UNUSED */
957 (void)md; /* UNUSED */
958 return (ARCHIVE_FAILED);
963 /* SHA384 implementations */
964 #if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
967 __archive_sha384init(archive_sha384_ctx *ctx)
974 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
977 SHA384_Update(ctx, indata, insize);
982 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
984 SHA384_Final(md, ctx);
988 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
991 __archive_sha384init(archive_sha384_ctx *ctx)
998 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1001 SHA384Update(ctx, indata, insize);
1002 return (ARCHIVE_OK);
1006 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1008 SHA384Final(md, ctx);
1009 return (ARCHIVE_OK);
1012 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
1015 __archive_sha384init(archive_sha384_ctx *ctx)
1018 return (ARCHIVE_OK);
1022 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1025 SHA384Update(ctx, indata, insize);
1026 return (ARCHIVE_OK);
1030 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1032 SHA384Final(md, ctx);
1033 return (ARCHIVE_OK);
1036 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
1039 __archive_sha384init(archive_sha384_ctx *ctx)
1041 CC_SHA384_Init(ctx);
1042 return (ARCHIVE_OK);
1046 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1049 CC_SHA384_Update(ctx, indata, insize);
1050 return (ARCHIVE_OK);
1054 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1056 CC_SHA384_Final(md, ctx);
1057 return (ARCHIVE_OK);
1060 #elif defined(ARCHIVE_CRYPTO_SHA384_MBEDTLS)
1063 __archive_sha384init(archive_sha384_ctx *ctx)
1065 mbedtls_sha512_init(ctx);
1066 if (mbedtls_sha512_starts_ret(ctx, 1) == 0)
1067 return (ARCHIVE_OK);
1069 return (ARCHIVE_FATAL);
1073 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1076 if (mbedtls_sha512_update_ret(ctx, indata, insize) == 0)
1077 return (ARCHIVE_OK);
1079 return (ARCHIVE_FATAL);
1083 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1085 if (mbedtls_sha512_finish_ret(ctx, md) == 0) {
1086 mbedtls_sha512_free(ctx);
1087 return (ARCHIVE_OK);
1089 mbedtls_sha512_free(ctx);
1090 return (ARCHIVE_FATAL);
1094 #elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
1097 __archive_sha384init(archive_sha384_ctx *ctx)
1100 return (ARCHIVE_OK);
1104 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1107 sha384_update(ctx, insize, indata);
1108 return (ARCHIVE_OK);
1112 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1114 sha384_digest(ctx, SHA384_DIGEST_SIZE, md);
1115 return (ARCHIVE_OK);
1118 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
1121 __archive_sha384init(archive_sha384_ctx *ctx)
1123 if ((*ctx = EVP_MD_CTX_new()) == NULL)
1124 return (ARCHIVE_FAILED);
1125 EVP_DigestInit(*ctx, EVP_sha384());
1126 return (ARCHIVE_OK);
1130 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1133 EVP_DigestUpdate(*ctx, indata, insize);
1134 return (ARCHIVE_OK);
1138 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1141 EVP_DigestFinal(*ctx, md, NULL);
1142 EVP_MD_CTX_free(*ctx);
1145 return (ARCHIVE_OK);
1148 #elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
1151 __archive_sha384init(archive_sha384_ctx *ctx)
1153 return (win_crypto_init(ctx, CALG_SHA_384));
1157 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1160 return (win_crypto_Update(ctx, indata, insize));
1164 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1166 return (win_crypto_Final(md, 48, ctx));
1172 __archive_sha384init(archive_sha384_ctx *ctx)
1174 (void)ctx; /* UNUSED */
1175 return (ARCHIVE_FAILED);
1179 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1182 (void)ctx; /* UNUSED */
1183 (void)indata; /* UNUSED */
1184 (void)insize; /* UNUSED */
1185 return (ARCHIVE_FAILED);
1189 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1191 (void)ctx; /* UNUSED */
1192 (void)md; /* UNUSED */
1193 return (ARCHIVE_FAILED);
1198 /* SHA512 implementations */
1199 #if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1202 __archive_sha512init(archive_sha512_ctx *ctx)
1205 return (ARCHIVE_OK);
1209 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1212 SHA512_Update(ctx, indata, insize);
1213 return (ARCHIVE_OK);
1217 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1219 SHA512_Final(md, ctx);
1220 return (ARCHIVE_OK);
1223 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1226 __archive_sha512init(archive_sha512_ctx *ctx)
1229 return (ARCHIVE_OK);
1233 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1236 SHA512Update(ctx, indata, insize);
1237 return (ARCHIVE_OK);
1241 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1243 SHA512Final(md, ctx);
1244 return (ARCHIVE_OK);
1247 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1250 __archive_sha512init(archive_sha512_ctx *ctx)
1253 return (ARCHIVE_OK);
1257 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1260 SHA512Update(ctx, indata, insize);
1261 return (ARCHIVE_OK);
1265 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1267 SHA512Final(md, ctx);
1268 return (ARCHIVE_OK);
1271 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1274 __archive_sha512init(archive_sha512_ctx *ctx)
1277 return (ARCHIVE_OK);
1281 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1284 SHA512_Update(ctx, indata, insize);
1285 return (ARCHIVE_OK);
1289 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1291 SHA512_Final(md, ctx);
1292 return (ARCHIVE_OK);
1295 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1298 __archive_sha512init(archive_sha512_ctx *ctx)
1300 CC_SHA512_Init(ctx);
1301 return (ARCHIVE_OK);
1305 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1308 CC_SHA512_Update(ctx, indata, insize);
1309 return (ARCHIVE_OK);
1313 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1315 CC_SHA512_Final(md, ctx);
1316 return (ARCHIVE_OK);
1319 #elif defined(ARCHIVE_CRYPTO_SHA512_MBEDTLS)
1322 __archive_sha512init(archive_sha512_ctx *ctx)
1324 mbedtls_sha512_init(ctx);
1325 if (mbedtls_sha512_starts_ret(ctx, 0) == 0)
1326 return (ARCHIVE_OK);
1328 return (ARCHIVE_FATAL);
1332 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1335 if (mbedtls_sha512_update_ret(ctx, indata, insize) == 0)
1336 return (ARCHIVE_OK);
1338 return (ARCHIVE_FATAL);
1342 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1344 if (mbedtls_sha512_finish_ret(ctx, md) == 0) {
1345 mbedtls_sha512_free(ctx);
1346 return (ARCHIVE_OK);
1348 mbedtls_sha512_free(ctx);
1349 return (ARCHIVE_FATAL);
1353 #elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1356 __archive_sha512init(archive_sha512_ctx *ctx)
1359 return (ARCHIVE_OK);
1363 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1366 sha512_update(ctx, insize, indata);
1367 return (ARCHIVE_OK);
1371 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1373 sha512_digest(ctx, SHA512_DIGEST_SIZE, md);
1374 return (ARCHIVE_OK);
1377 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1380 __archive_sha512init(archive_sha512_ctx *ctx)
1382 if ((*ctx = EVP_MD_CTX_new()) == NULL)
1383 return (ARCHIVE_FAILED);
1384 EVP_DigestInit(*ctx, EVP_sha512());
1385 return (ARCHIVE_OK);
1389 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1392 EVP_DigestUpdate(*ctx, indata, insize);
1393 return (ARCHIVE_OK);
1397 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1400 EVP_DigestFinal(*ctx, md, NULL);
1401 EVP_MD_CTX_free(*ctx);
1404 return (ARCHIVE_OK);
1407 #elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1410 __archive_sha512init(archive_sha512_ctx *ctx)
1412 return (win_crypto_init(ctx, CALG_SHA_512));
1416 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1419 return (win_crypto_Update(ctx, indata, insize));
1423 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1425 return (win_crypto_Final(md, 64, ctx));
1431 __archive_sha512init(archive_sha512_ctx *ctx)
1433 (void)ctx; /* UNUSED */
1434 return (ARCHIVE_FAILED);
1438 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1441 (void)ctx; /* UNUSED */
1442 (void)indata; /* UNUSED */
1443 (void)insize; /* UNUSED */
1444 return (ARCHIVE_FAILED);
1448 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1450 (void)ctx; /* UNUSED */
1451 (void)md; /* UNUSED */
1452 return (ARCHIVE_FAILED);
1457 /* NOTE: Message Digest functions are set based on availability and by the
1458 * following order of preference.
1468 const struct archive_digest __archive_digest =
1472 &__archive_md5update,
1473 &__archive_md5final,
1476 &__archive_ripemd160init,
1477 &__archive_ripemd160update,
1478 &__archive_ripemd160final,
1481 &__archive_sha1init,
1482 &__archive_sha1update,
1483 &__archive_sha1final,
1486 &__archive_sha256init,
1487 &__archive_sha256update,
1488 &__archive_sha256final,
1491 &__archive_sha384init,
1492 &__archive_sha384update,
1493 &__archive_sha384final,
1496 &__archive_sha512init,
1497 &__archive_sha512update,
1498 &__archive_sha512final