1 /*-
2 * Copyright (c) 2003-2007 Tim Kientzle
3 * Copyright (c) 2011 Andres Mejia
4 * Copyright (c) 2011 Michihiro NAKAJIMA
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
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.
15 *
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.
26 */
27 
28 #include "archive_platform.h"
29 
30 #include "archive.h"
31 #include "archive_digest_private.h"
32 
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.
37 #endif
38 
39 /* Common in other bcrypt implementations, but missing from VS2008. */
40 #ifndef BCRYPT_SUCCESS
41 #define BCRYPT_SUCCESS(r) ((NTSTATUS)(r) == STATUS_SUCCESS)
42 #endif
43 
44 /*
45  * Message digest functions for Windows platform.
46  */
47 #if defined(ARCHIVE_CRYPTO_MD5_WIN)    ||\
48 	defined(ARCHIVE_CRYPTO_SHA1_WIN)   ||\
49 	defined(ARCHIVE_CRYPTO_SHA256_WIN) ||\
50 	defined(ARCHIVE_CRYPTO_SHA384_WIN) ||\
51 	defined(ARCHIVE_CRYPTO_SHA512_WIN)
52 
53 /*
54  * Initialize a Message digest.
55  */
56 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
57 static int
58 win_crypto_init(Digest_CTX *ctx, const WCHAR *algo)
59 {
60 	NTSTATUS status;
61 	ctx->valid = 0;
62 
63 	status = BCryptOpenAlgorithmProvider(&ctx->hAlg, algo, NULL, 0);
64 	if (!BCRYPT_SUCCESS(status))
65 		return (ARCHIVE_FAILED);
66 	status = BCryptCreateHash(ctx->hAlg, &ctx->hHash, NULL, 0, NULL, 0, 0);
67 	if (!BCRYPT_SUCCESS(status)) {
68 		BCryptCloseAlgorithmProvider(ctx->hAlg, 0);
69 		return (ARCHIVE_FAILED);
70 	}
71 
72 	ctx->valid = 1;
73 	return (ARCHIVE_OK);
74 }
75 #else
76 static int
77 win_crypto_init(Digest_CTX *ctx, DWORD prov, ALG_ID algId)
78 {
79 
80 	ctx->valid = 0;
81 	if (!CryptAcquireContext(&ctx->cryptProv, NULL, NULL,
82 	    prov, CRYPT_VERIFYCONTEXT)) {
83 		if (GetLastError() != (DWORD)NTE_BAD_KEYSET)
84 			return (ARCHIVE_FAILED);
85 		if (!CryptAcquireContext(&ctx->cryptProv, NULL, NULL,
86 		    prov, CRYPT_NEWKEYSET))
87 			return (ARCHIVE_FAILED);
88 	}
89 
90 	if (!CryptCreateHash(ctx->cryptProv, algId, 0, 0, &ctx->hash)) {
91 		CryptReleaseContext(ctx->cryptProv, 0);
92 		return (ARCHIVE_FAILED);
93 	}
94 
95 	ctx->valid = 1;
96 	return (ARCHIVE_OK);
97 }
98 #endif
99 
100 /*
101  * Update a Message digest.
102  */
103 static int
104 win_crypto_Update(Digest_CTX *ctx, const unsigned char *buf, size_t len)
105 {
106 
107 	if (!ctx->valid)
108 		return (ARCHIVE_FAILED);
109 
110 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
111 	BCryptHashData(ctx->hHash,
112 		      (PUCHAR)(uintptr_t)buf,
113 		      (ULONG)len, 0);
114 #else
115 	CryptHashData(ctx->hash,
116 		      (unsigned char *)(uintptr_t)buf,
117 		      (DWORD)len, 0);
118 #endif
119 	return (ARCHIVE_OK);
120 }
121 
122 static int
123 win_crypto_Final(unsigned char *buf, size_t bufsize, Digest_CTX *ctx)
124 {
125 #if !(defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA)
126 	DWORD siglen = (DWORD)bufsize;
127 #endif
128 
129 	if (!ctx->valid)
130 		return (ARCHIVE_FAILED);
131 
132 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
133 	BCryptFinishHash(ctx->hHash, buf, (ULONG)bufsize, 0);
134 	BCryptDestroyHash(ctx->hHash);
135 	BCryptCloseAlgorithmProvider(ctx->hAlg, 0);
136 #else
137 	CryptGetHashParam(ctx->hash, HP_HASHVAL, buf, &siglen, 0);
138 	CryptDestroyHash(ctx->hash);
139 	CryptReleaseContext(ctx->cryptProv, 0);
140 #endif
141 	ctx->valid = 0;
142 	return (ARCHIVE_OK);
143 }
144 
145 #endif /* defined(ARCHIVE_CRYPTO_*_WIN) */
146 
147 
148 /* MD5 implementations */
149 #if defined(ARCHIVE_CRYPTO_MD5_LIBC)
150 
151 static int
152 __archive_md5init(archive_md5_ctx *ctx)
153 {
154   MD5Init(ctx);
155   return (ARCHIVE_OK);
156 }
157 
158 static int
159 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
160     size_t insize)
161 {
162   MD5Update(ctx, indata, insize);
163   return (ARCHIVE_OK);
164 }
165 
166 static int
167 __archive_md5final(archive_md5_ctx *ctx, void *md)
168 {
169   MD5Final(md, ctx);
170   return (ARCHIVE_OK);
171 }
172 
173 #elif defined(ARCHIVE_CRYPTO_MD5_LIBMD)
174 
175 static int
176 __archive_md5init(archive_md5_ctx *ctx)
177 {
178   MD5Init(ctx);
179   return (ARCHIVE_OK);
180 }
181 
182 static int
183 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
184     size_t insize)
185 {
186   MD5Update(ctx, indata, insize);
187   return (ARCHIVE_OK);
188 }
189 
190 static int
191 __archive_md5final(archive_md5_ctx *ctx, void *md)
192 {
193   MD5Final(md, ctx);
194   return (ARCHIVE_OK);
195 }
196 
197 #elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM)
198 
199 static int
200 __archive_md5init(archive_md5_ctx *ctx)
201 {
202   CC_MD5_Init(ctx);
203   return (ARCHIVE_OK);
204 }
205 
206 static int
207 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
208     size_t insize)
209 {
210   CC_MD5_Update(ctx, indata, insize);
211   return (ARCHIVE_OK);
212 }
213 
214 static int
215 __archive_md5final(archive_md5_ctx *ctx, void *md)
216 {
217   CC_MD5_Final(md, ctx);
218   return (ARCHIVE_OK);
219 }
220 
221 #elif defined(ARCHIVE_CRYPTO_MD5_MBEDTLS)
222 
223 static int
224 __archive_md5init(archive_md5_ctx *ctx)
225 {
226   mbedtls_md5_init(ctx);
227   if (mbedtls_md5_starts_ret(ctx) == 0)
228     return (ARCHIVE_OK);
229   else
230     return (ARCHIVE_FATAL);
231 }
232 
233 static int
234 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
235     size_t insize)
236 {
237   if (mbedtls_md5_update_ret(ctx, indata, insize) == 0)
238     return (ARCHIVE_OK);
239   else
240     return (ARCHIVE_FATAL);
241 }
242 
243 static int
244 __archive_md5final(archive_md5_ctx *ctx, void *md)
245 {
246   if (mbedtls_md5_finish_ret(ctx, md) == 0) {
247     mbedtls_md5_free(ctx);
248     return (ARCHIVE_OK);
249   } else {
250     mbedtls_md5_free(ctx);
251     return (ARCHIVE_FATAL);
252   }
253 }
254 
255 #elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
256 
257 static int
258 __archive_md5init(archive_md5_ctx *ctx)
259 {
260   md5_init(ctx);
261   return (ARCHIVE_OK);
262 }
263 
264 static int
265 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
266     size_t insize)
267 {
268   md5_update(ctx, insize, indata);
269   return (ARCHIVE_OK);
270 }
271 
272 static int
273 __archive_md5final(archive_md5_ctx *ctx, void *md)
274 {
275   md5_digest(ctx, MD5_DIGEST_SIZE, md);
276   return (ARCHIVE_OK);
277 }
278 
279 #elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
280 
281 static int
282 __archive_md5init(archive_md5_ctx *ctx)
283 {
284   if ((*ctx = EVP_MD_CTX_new()) == NULL)
285 	return (ARCHIVE_FAILED);
286   if (!EVP_DigestInit(*ctx, EVP_md5()))
287 	return (ARCHIVE_FAILED);
288   return (ARCHIVE_OK);
289 }
290 
291 static int
292 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
293     size_t insize)
294 {
295   EVP_DigestUpdate(*ctx, indata, insize);
296   return (ARCHIVE_OK);
297 }
298 
299 static int
300 __archive_md5final(archive_md5_ctx *ctx, void *md)
301 {
302   /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
303    * this is meant to cope with that. Real fix is probably to fix
304    * archive_write_set_format_xar.c
305    */
306   if (*ctx) {
307     EVP_DigestFinal(*ctx, md, NULL);
308     EVP_MD_CTX_free(*ctx);
309     *ctx = NULL;
310   }
311   return (ARCHIVE_OK);
312 }
313 
314 #elif defined(ARCHIVE_CRYPTO_MD5_WIN)
315 
316 static int
317 __archive_md5init(archive_md5_ctx *ctx)
318 {
319 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
320   return (win_crypto_init(ctx, BCRYPT_MD5_ALGORITHM));
321 #else
322   return (win_crypto_init(ctx, PROV_RSA_FULL, CALG_MD5));
323 #endif
324 }
325 
326 static int
327 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
328     size_t insize)
329 {
330   return (win_crypto_Update(ctx, indata, insize));
331 }
332 
333 static int
334 __archive_md5final(archive_md5_ctx *ctx, void *md)
335 {
336   return (win_crypto_Final(md, 16, ctx));
337 }
338 
339 #else
340 
341 static int
342 __archive_md5init(archive_md5_ctx *ctx)
343 {
344 	(void)ctx; /* UNUSED */
345 	return (ARCHIVE_FAILED);
346 }
347 
348 static int
349 __archive_md5update(archive_md5_ctx *ctx, const void *indata,
350     size_t insize)
351 {
352 	(void)ctx; /* UNUSED */
353 	(void)indata; /* UNUSED */
354 	(void)insize; /* UNUSED */
355 	return (ARCHIVE_FAILED);
356 }
357 
358 static int
359 __archive_md5final(archive_md5_ctx *ctx, void *md)
360 {
361 	(void)ctx; /* UNUSED */
362 	(void)md; /* UNUSED */
363 	return (ARCHIVE_FAILED);
364 }
365 
366 #endif
367 
368 /* RIPEMD160 implementations */
369 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
370 
371 static int
372 __archive_ripemd160init(archive_rmd160_ctx *ctx)
373 {
374   RMD160Init(ctx);
375   return (ARCHIVE_OK);
376 }
377 
378 static int
379 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
380     size_t insize)
381 {
382   RMD160Update(ctx, indata, insize);
383   return (ARCHIVE_OK);
384 }
385 
386 static int
387 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
388 {
389   RMD160Final(md, ctx);
390   return (ARCHIVE_OK);
391 }
392 
393 #elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
394 
395 static int
396 __archive_ripemd160init(archive_rmd160_ctx *ctx)
397 {
398   RIPEMD160_Init(ctx);
399   return (ARCHIVE_OK);
400 }
401 
402 static int
403 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
404     size_t insize)
405 {
406   RIPEMD160_Update(ctx, indata, insize);
407   return (ARCHIVE_OK);
408 }
409 
410 static int
411 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
412 {
413   RIPEMD160_Final(md, ctx);
414   return (ARCHIVE_OK);
415 }
416 
417 #elif defined(ARCHIVE_CRYPTO_RMD160_MBEDTLS)
418 
419 static int
420 __archive_ripemd160init(archive_rmd160_ctx *ctx)
421 {
422   mbedtls_ripemd160_init(ctx);
423   if (mbedtls_ripemd160_starts_ret(ctx) == 0)
424     return (ARCHIVE_OK);
425   else
426     return (ARCHIVE_FATAL);
427 }
428 
429 static int
430 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
431     size_t insize)
432 {
433   if (mbedtls_ripemd160_update_ret(ctx, indata, insize) == 0)
434     return (ARCHIVE_OK);
435   else
436     return (ARCHIVE_FATAL);
437 }
438 
439 static int
440 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
441 {
442   if (mbedtls_ripemd160_finish_ret(ctx, md) == 0) {
443     mbedtls_ripemd160_free(ctx);
444     return (ARCHIVE_OK);
445   } else {
446     mbedtls_ripemd160_free(ctx);
447     return (ARCHIVE_FATAL);
448   }
449 }
450 
451 #elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
452 
453 static int
454 __archive_ripemd160init(archive_rmd160_ctx *ctx)
455 {
456   ripemd160_init(ctx);
457   return (ARCHIVE_OK);
458 }
459 
460 static int
461 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
462     size_t insize)
463 {
464   ripemd160_update(ctx, insize, indata);
465   return (ARCHIVE_OK);
466 }
467 
468 static int
469 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
470 {
471   ripemd160_digest(ctx, RIPEMD160_DIGEST_SIZE, md);
472   return (ARCHIVE_OK);
473 }
474 
475 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
476 
477 static int
478 __archive_ripemd160init(archive_rmd160_ctx *ctx)
479 {
480   if ((*ctx = EVP_MD_CTX_new()) == NULL)
481 	return (ARCHIVE_FAILED);
482   if (!EVP_DigestInit(*ctx, EVP_ripemd160()))
483 	return (ARCHIVE_FAILED);
484   return (ARCHIVE_OK);
485 }
486 
487 static int
488 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
489     size_t insize)
490 {
491   EVP_DigestUpdate(*ctx, indata, insize);
492   return (ARCHIVE_OK);
493 }
494 
495 static int
496 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
497 {
498   if (*ctx) {
499     EVP_DigestFinal(*ctx, md, NULL);
500     EVP_MD_CTX_free(*ctx);
501     *ctx = NULL;
502   }
503   return (ARCHIVE_OK);
504 }
505 
506 #else
507 
508 static int
509 __archive_ripemd160init(archive_rmd160_ctx *ctx)
510 {
511 	(void)ctx; /* UNUSED */
512 	return (ARCHIVE_FAILED);
513 }
514 
515 static int
516 __archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
517     size_t insize)
518 {
519 	(void)ctx; /* UNUSED */
520 	(void)indata; /* UNUSED */
521 	(void)insize; /* UNUSED */
522 	return (ARCHIVE_FAILED);
523 }
524 
525 static int
526 __archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
527 {
528 	(void)ctx; /* UNUSED */
529 	(void)md; /* UNUSED */
530 	return (ARCHIVE_FAILED);
531 }
532 
533 #endif
534 
535 /* SHA1 implementations */
536 #if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
537 
538 static int
539 __archive_sha1init(archive_sha1_ctx *ctx)
540 {
541   SHA1Init(ctx);
542   return (ARCHIVE_OK);
543 }
544 
545 static int
546 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
547     size_t insize)
548 {
549   SHA1Update(ctx, indata, insize);
550   return (ARCHIVE_OK);
551 }
552 
553 static int
554 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
555 {
556   SHA1Final(md, ctx);
557   return (ARCHIVE_OK);
558 }
559 
560 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
561 
562 static int
563 __archive_sha1init(archive_sha1_ctx *ctx)
564 {
565   SHA1_Init(ctx);
566   return (ARCHIVE_OK);
567 }
568 
569 static int
570 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
571     size_t insize)
572 {
573   SHA1_Update(ctx, indata, insize);
574   return (ARCHIVE_OK);
575 }
576 
577 static int
578 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
579 {
580   SHA1_Final(md, ctx);
581   return (ARCHIVE_OK);
582 }
583 
584 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
585 
586 static int
587 __archive_sha1init(archive_sha1_ctx *ctx)
588 {
589   CC_SHA1_Init(ctx);
590   return (ARCHIVE_OK);
591 }
592 
593 static int
594 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
595     size_t insize)
596 {
597   CC_SHA1_Update(ctx, indata, insize);
598   return (ARCHIVE_OK);
599 }
600 
601 static int
602 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
603 {
604   CC_SHA1_Final(md, ctx);
605   return (ARCHIVE_OK);
606 }
607 
608 #elif defined(ARCHIVE_CRYPTO_SHA1_MBEDTLS)
609 
610 static int
611 __archive_sha1init(archive_sha1_ctx *ctx)
612 {
613   mbedtls_sha1_init(ctx);
614   if (mbedtls_sha1_starts_ret(ctx) == 0)
615     return (ARCHIVE_OK);
616   else
617     return (ARCHIVE_FATAL);
618 }
619 
620 static int
621 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
622     size_t insize)
623 {
624   if (mbedtls_sha1_update_ret(ctx, indata, insize) == 0)
625     return (ARCHIVE_OK);
626   else
627     return (ARCHIVE_FATAL);
628 }
629 
630 static int
631 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
632 {
633   if (mbedtls_sha1_finish_ret(ctx, md) == 0) {
634     mbedtls_sha1_free(ctx);
635     return (ARCHIVE_OK);
636   } else {
637     mbedtls_sha1_free(ctx);
638     return (ARCHIVE_FATAL);
639   }
640 }
641 
642 #elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
643 
644 static int
645 __archive_sha1init(archive_sha1_ctx *ctx)
646 {
647   sha1_init(ctx);
648   return (ARCHIVE_OK);
649 }
650 
651 static int
652 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
653     size_t insize)
654 {
655   sha1_update(ctx, insize, indata);
656   return (ARCHIVE_OK);
657 }
658 
659 static int
660 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
661 {
662   sha1_digest(ctx, SHA1_DIGEST_SIZE, md);
663   return (ARCHIVE_OK);
664 }
665 
666 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
667 
668 static int
669 __archive_sha1init(archive_sha1_ctx *ctx)
670 {
671   if ((*ctx = EVP_MD_CTX_new()) == NULL)
672 	return (ARCHIVE_FAILED);
673   if (!EVP_DigestInit(*ctx, EVP_sha1()))
674 	return (ARCHIVE_FAILED);
675   return (ARCHIVE_OK);
676 }
677 
678 static int
679 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
680     size_t insize)
681 {
682   EVP_DigestUpdate(*ctx, indata, insize);
683   return (ARCHIVE_OK);
684 }
685 
686 static int
687 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
688 {
689   /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
690    * this is meant to cope with that. Real fix is probably to fix
691    * archive_write_set_format_xar.c
692    */
693   if (*ctx) {
694     EVP_DigestFinal(*ctx, md, NULL);
695     EVP_MD_CTX_free(*ctx);
696     *ctx = NULL;
697   }
698   return (ARCHIVE_OK);
699 }
700 
701 #elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
702 
703 static int
704 __archive_sha1init(archive_sha1_ctx *ctx)
705 {
706 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
707   return (win_crypto_init(ctx, BCRYPT_SHA1_ALGORITHM));
708 #else
709   return (win_crypto_init(ctx, PROV_RSA_FULL, CALG_SHA1));
710 #endif
711 }
712 
713 static int
714 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
715     size_t insize)
716 {
717   return (win_crypto_Update(ctx, indata, insize));
718 }
719 
720 static int
721 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
722 {
723   return (win_crypto_Final(md, 20, ctx));
724 }
725 
726 #else
727 
728 static int
729 __archive_sha1init(archive_sha1_ctx *ctx)
730 {
731 	(void)ctx; /* UNUSED */
732 	return (ARCHIVE_FAILED);
733 }
734 
735 static int
736 __archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
737     size_t insize)
738 {
739 	(void)ctx; /* UNUSED */
740 	(void)indata; /* UNUSED */
741 	(void)insize; /* UNUSED */
742 	return (ARCHIVE_FAILED);
743 }
744 
745 static int
746 __archive_sha1final(archive_sha1_ctx *ctx, void *md)
747 {
748 	(void)ctx; /* UNUSED */
749 	(void)md; /* UNUSED */
750 	return (ARCHIVE_FAILED);
751 }
752 
753 #endif
754 
755 /* SHA256 implementations */
756 #if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
757 
758 static int
759 __archive_sha256init(archive_sha256_ctx *ctx)
760 {
761   SHA256_Init(ctx);
762   return (ARCHIVE_OK);
763 }
764 
765 static int
766 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
767     size_t insize)
768 {
769   SHA256_Update(ctx, indata, insize);
770   return (ARCHIVE_OK);
771 }
772 
773 static int
774 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
775 {
776   SHA256_Final(md, ctx);
777   return (ARCHIVE_OK);
778 }
779 
780 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
781 
782 static int
783 __archive_sha256init(archive_sha256_ctx *ctx)
784 {
785   SHA256Init(ctx);
786   return (ARCHIVE_OK);
787 }
788 
789 static int
790 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
791     size_t insize)
792 {
793   SHA256Update(ctx, indata, insize);
794   return (ARCHIVE_OK);
795 }
796 
797 static int
798 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
799 {
800   SHA256Final(md, ctx);
801   return (ARCHIVE_OK);
802 }
803 
804 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
805 
806 static int
807 __archive_sha256init(archive_sha256_ctx *ctx)
808 {
809   SHA256Init(ctx);
810   return (ARCHIVE_OK);
811 }
812 
813 static int
814 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
815     size_t insize)
816 {
817   SHA256Update(ctx, indata, insize);
818   return (ARCHIVE_OK);
819 }
820 
821 static int
822 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
823 {
824   SHA256Final(md, ctx);
825   return (ARCHIVE_OK);
826 }
827 
828 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
829 
830 static int
831 __archive_sha256init(archive_sha256_ctx *ctx)
832 {
833   SHA256_Init(ctx);
834   return (ARCHIVE_OK);
835 }
836 
837 static int
838 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
839     size_t insize)
840 {
841   SHA256_Update(ctx, indata, insize);
842   return (ARCHIVE_OK);
843 }
844 
845 static int
846 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
847 {
848   SHA256_Final(md, ctx);
849   return (ARCHIVE_OK);
850 }
851 
852 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
853 
854 static int
855 __archive_sha256init(archive_sha256_ctx *ctx)
856 {
857   CC_SHA256_Init(ctx);
858   return (ARCHIVE_OK);
859 }
860 
861 static int
862 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
863     size_t insize)
864 {
865   CC_SHA256_Update(ctx, indata, insize);
866   return (ARCHIVE_OK);
867 }
868 
869 static int
870 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
871 {
872   CC_SHA256_Final(md, ctx);
873   return (ARCHIVE_OK);
874 }
875 
876 #elif defined(ARCHIVE_CRYPTO_SHA256_MBEDTLS)
877 
878 static int
879 __archive_sha256init(archive_sha256_ctx *ctx)
880 {
881   mbedtls_sha256_init(ctx);
882   if (mbedtls_sha256_starts_ret(ctx, 0) == 0)
883     return (ARCHIVE_OK);
884   else
885     return (ARCHIVE_FATAL);
886 }
887 
888 static int
889 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
890     size_t insize)
891 {
892   if (mbedtls_sha256_update_ret(ctx, indata, insize) == 0)
893     return (ARCHIVE_OK);
894   else
895     return (ARCHIVE_FATAL);
896 }
897 
898 static int
899 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
900 {
901   if (mbedtls_sha256_finish_ret(ctx, md) == 0) {
902     mbedtls_sha256_free(ctx);
903     return (ARCHIVE_OK);
904   } else {
905     mbedtls_sha256_free(ctx);
906     return (ARCHIVE_FATAL);
907   }
908 }
909 
910 #elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
911 
912 static int
913 __archive_sha256init(archive_sha256_ctx *ctx)
914 {
915   sha256_init(ctx);
916   return (ARCHIVE_OK);
917 }
918 
919 static int
920 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
921     size_t insize)
922 {
923   sha256_update(ctx, insize, indata);
924   return (ARCHIVE_OK);
925 }
926 
927 static int
928 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
929 {
930   sha256_digest(ctx, SHA256_DIGEST_SIZE, md);
931   return (ARCHIVE_OK);
932 }
933 
934 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
935 
936 static int
937 __archive_sha256init(archive_sha256_ctx *ctx)
938 {
939   if ((*ctx = EVP_MD_CTX_new()) == NULL)
940 	return (ARCHIVE_FAILED);
941   if (!EVP_DigestInit(*ctx, EVP_sha256()))
942 	return (ARCHIVE_FAILED);
943   return (ARCHIVE_OK);
944 }
945 
946 static int
947 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
948     size_t insize)
949 {
950   EVP_DigestUpdate(*ctx, indata, insize);
951   return (ARCHIVE_OK);
952 }
953 
954 static int
955 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
956 {
957   if (*ctx) {
958     EVP_DigestFinal(*ctx, md, NULL);
959     EVP_MD_CTX_free(*ctx);
960     *ctx = NULL;
961   }
962   return (ARCHIVE_OK);
963 }
964 
965 #elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
966 
967 static int
968 __archive_sha256init(archive_sha256_ctx *ctx)
969 {
970 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
971   return (win_crypto_init(ctx, BCRYPT_SHA256_ALGORITHM));
972 #else
973   return (win_crypto_init(ctx, PROV_RSA_AES, CALG_SHA_256));
974 #endif
975 }
976 
977 static int
978 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
979     size_t insize)
980 {
981   return (win_crypto_Update(ctx, indata, insize));
982 }
983 
984 static int
985 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
986 {
987   return (win_crypto_Final(md, 32, ctx));
988 }
989 
990 #else
991 
992 static int
993 __archive_sha256init(archive_sha256_ctx *ctx)
994 {
995 	(void)ctx; /* UNUSED */
996 	return (ARCHIVE_FAILED);
997 }
998 
999 static int
1000 __archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
1001     size_t insize)
1002 {
1003 	(void)ctx; /* UNUSED */
1004 	(void)indata; /* UNUSED */
1005 	(void)insize; /* UNUSED */
1006 	return (ARCHIVE_FAILED);
1007 }
1008 
1009 static int
1010 __archive_sha256final(archive_sha256_ctx *ctx, void *md)
1011 {
1012 	(void)ctx; /* UNUSED */
1013 	(void)md; /* UNUSED */
1014 	return (ARCHIVE_FAILED);
1015 }
1016 
1017 #endif
1018 
1019 /* SHA384 implementations */
1020 #if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
1021 
1022 static int
1023 __archive_sha384init(archive_sha384_ctx *ctx)
1024 {
1025   SHA384_Init(ctx);
1026   return (ARCHIVE_OK);
1027 }
1028 
1029 static int
1030 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1031     size_t insize)
1032 {
1033   SHA384_Update(ctx, indata, insize);
1034   return (ARCHIVE_OK);
1035 }
1036 
1037 static int
1038 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1039 {
1040   SHA384_Final(md, ctx);
1041   return (ARCHIVE_OK);
1042 }
1043 
1044 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
1045 
1046 static int
1047 __archive_sha384init(archive_sha384_ctx *ctx)
1048 {
1049   SHA384Init(ctx);
1050   return (ARCHIVE_OK);
1051 }
1052 
1053 static int
1054 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1055     size_t insize)
1056 {
1057   SHA384Update(ctx, indata, insize);
1058   return (ARCHIVE_OK);
1059 }
1060 
1061 static int
1062 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1063 {
1064   SHA384Final(md, ctx);
1065   return (ARCHIVE_OK);
1066 }
1067 
1068 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
1069 
1070 static int
1071 __archive_sha384init(archive_sha384_ctx *ctx)
1072 {
1073   SHA384Init(ctx);
1074   return (ARCHIVE_OK);
1075 }
1076 
1077 static int
1078 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1079     size_t insize)
1080 {
1081   SHA384Update(ctx, indata, insize);
1082   return (ARCHIVE_OK);
1083 }
1084 
1085 static int
1086 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1087 {
1088   SHA384Final(md, ctx);
1089   return (ARCHIVE_OK);
1090 }
1091 
1092 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
1093 
1094 static int
1095 __archive_sha384init(archive_sha384_ctx *ctx)
1096 {
1097   CC_SHA384_Init(ctx);
1098   return (ARCHIVE_OK);
1099 }
1100 
1101 static int
1102 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1103     size_t insize)
1104 {
1105   CC_SHA384_Update(ctx, indata, insize);
1106   return (ARCHIVE_OK);
1107 }
1108 
1109 static int
1110 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1111 {
1112   CC_SHA384_Final(md, ctx);
1113   return (ARCHIVE_OK);
1114 }
1115 
1116 #elif defined(ARCHIVE_CRYPTO_SHA384_MBEDTLS)
1117 
1118 static int
1119 __archive_sha384init(archive_sha384_ctx *ctx)
1120 {
1121   mbedtls_sha512_init(ctx);
1122   if (mbedtls_sha512_starts_ret(ctx, 1) == 0)
1123     return (ARCHIVE_OK);
1124   else
1125     return (ARCHIVE_FATAL);
1126 }
1127 
1128 static int
1129 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1130     size_t insize)
1131 {
1132   if (mbedtls_sha512_update_ret(ctx, indata, insize) == 0)
1133     return (ARCHIVE_OK);
1134   else
1135     return (ARCHIVE_FATAL);
1136 }
1137 
1138 static int
1139 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1140 {
1141   if (mbedtls_sha512_finish_ret(ctx, md) == 0) {
1142     mbedtls_sha512_free(ctx);
1143     return (ARCHIVE_OK);
1144   } else {
1145     mbedtls_sha512_free(ctx);
1146     return (ARCHIVE_FATAL);
1147   }
1148 }
1149 
1150 #elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
1151 
1152 static int
1153 __archive_sha384init(archive_sha384_ctx *ctx)
1154 {
1155   sha384_init(ctx);
1156   return (ARCHIVE_OK);
1157 }
1158 
1159 static int
1160 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1161     size_t insize)
1162 {
1163   sha384_update(ctx, insize, indata);
1164   return (ARCHIVE_OK);
1165 }
1166 
1167 static int
1168 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1169 {
1170   sha384_digest(ctx, SHA384_DIGEST_SIZE, md);
1171   return (ARCHIVE_OK);
1172 }
1173 
1174 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
1175 
1176 static int
1177 __archive_sha384init(archive_sha384_ctx *ctx)
1178 {
1179   if ((*ctx = EVP_MD_CTX_new()) == NULL)
1180 	return (ARCHIVE_FAILED);
1181   if (!EVP_DigestInit(*ctx, EVP_sha384()))
1182 	return (ARCHIVE_FAILED);
1183   return (ARCHIVE_OK);
1184 }
1185 
1186 static int
1187 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1188     size_t insize)
1189 {
1190   EVP_DigestUpdate(*ctx, indata, insize);
1191   return (ARCHIVE_OK);
1192 }
1193 
1194 static int
1195 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1196 {
1197   if (*ctx) {
1198     EVP_DigestFinal(*ctx, md, NULL);
1199     EVP_MD_CTX_free(*ctx);
1200     *ctx = NULL;
1201   }
1202   return (ARCHIVE_OK);
1203 }
1204 
1205 #elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
1206 
1207 static int
1208 __archive_sha384init(archive_sha384_ctx *ctx)
1209 {
1210 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
1211   return (win_crypto_init(ctx, BCRYPT_SHA384_ALGORITHM));
1212 #else
1213   return (win_crypto_init(ctx, PROV_RSA_AES, CALG_SHA_384));
1214 #endif
1215 }
1216 
1217 static int
1218 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1219     size_t insize)
1220 {
1221   return (win_crypto_Update(ctx, indata, insize));
1222 }
1223 
1224 static int
1225 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1226 {
1227   return (win_crypto_Final(md, 48, ctx));
1228 }
1229 
1230 #else
1231 
1232 static int
1233 __archive_sha384init(archive_sha384_ctx *ctx)
1234 {
1235 	(void)ctx; /* UNUSED */
1236 	return (ARCHIVE_FAILED);
1237 }
1238 
1239 static int
1240 __archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1241     size_t insize)
1242 {
1243 	(void)ctx; /* UNUSED */
1244 	(void)indata; /* UNUSED */
1245 	(void)insize; /* UNUSED */
1246 	return (ARCHIVE_FAILED);
1247 }
1248 
1249 static int
1250 __archive_sha384final(archive_sha384_ctx *ctx, void *md)
1251 {
1252 	(void)ctx; /* UNUSED */
1253 	(void)md; /* UNUSED */
1254 	return (ARCHIVE_FAILED);
1255 }
1256 
1257 #endif
1258 
1259 /* SHA512 implementations */
1260 #if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1261 
1262 static int
1263 __archive_sha512init(archive_sha512_ctx *ctx)
1264 {
1265   SHA512_Init(ctx);
1266   return (ARCHIVE_OK);
1267 }
1268 
1269 static int
1270 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1271     size_t insize)
1272 {
1273   SHA512_Update(ctx, indata, insize);
1274   return (ARCHIVE_OK);
1275 }
1276 
1277 static int
1278 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1279 {
1280   SHA512_Final(md, ctx);
1281   return (ARCHIVE_OK);
1282 }
1283 
1284 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1285 
1286 static int
1287 __archive_sha512init(archive_sha512_ctx *ctx)
1288 {
1289   SHA512Init(ctx);
1290   return (ARCHIVE_OK);
1291 }
1292 
1293 static int
1294 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1295     size_t insize)
1296 {
1297   SHA512Update(ctx, indata, insize);
1298   return (ARCHIVE_OK);
1299 }
1300 
1301 static int
1302 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1303 {
1304   SHA512Final(md, ctx);
1305   return (ARCHIVE_OK);
1306 }
1307 
1308 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1309 
1310 static int
1311 __archive_sha512init(archive_sha512_ctx *ctx)
1312 {
1313   SHA512Init(ctx);
1314   return (ARCHIVE_OK);
1315 }
1316 
1317 static int
1318 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1319     size_t insize)
1320 {
1321   SHA512Update(ctx, indata, insize);
1322   return (ARCHIVE_OK);
1323 }
1324 
1325 static int
1326 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1327 {
1328   SHA512Final(md, ctx);
1329   return (ARCHIVE_OK);
1330 }
1331 
1332 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1333 
1334 static int
1335 __archive_sha512init(archive_sha512_ctx *ctx)
1336 {
1337   SHA512_Init(ctx);
1338   return (ARCHIVE_OK);
1339 }
1340 
1341 static int
1342 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1343     size_t insize)
1344 {
1345   SHA512_Update(ctx, indata, insize);
1346   return (ARCHIVE_OK);
1347 }
1348 
1349 static int
1350 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1351 {
1352   SHA512_Final(md, ctx);
1353   return (ARCHIVE_OK);
1354 }
1355 
1356 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1357 
1358 static int
1359 __archive_sha512init(archive_sha512_ctx *ctx)
1360 {
1361   CC_SHA512_Init(ctx);
1362   return (ARCHIVE_OK);
1363 }
1364 
1365 static int
1366 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1367     size_t insize)
1368 {
1369   CC_SHA512_Update(ctx, indata, insize);
1370   return (ARCHIVE_OK);
1371 }
1372 
1373 static int
1374 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1375 {
1376   CC_SHA512_Final(md, ctx);
1377   return (ARCHIVE_OK);
1378 }
1379 
1380 #elif defined(ARCHIVE_CRYPTO_SHA512_MBEDTLS)
1381 
1382 static int
1383 __archive_sha512init(archive_sha512_ctx *ctx)
1384 {
1385   mbedtls_sha512_init(ctx);
1386   if (mbedtls_sha512_starts_ret(ctx, 0) == 0)
1387     return (ARCHIVE_OK);
1388   else
1389     return (ARCHIVE_FATAL);
1390 }
1391 
1392 static int
1393 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1394     size_t insize)
1395 {
1396   if (mbedtls_sha512_update_ret(ctx, indata, insize) == 0)
1397     return (ARCHIVE_OK);
1398   else
1399     return (ARCHIVE_FATAL);
1400 }
1401 
1402 static int
1403 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1404 {
1405   if (mbedtls_sha512_finish_ret(ctx, md) == 0) {
1406     mbedtls_sha512_free(ctx);
1407     return (ARCHIVE_OK);
1408   } else {
1409     mbedtls_sha512_free(ctx);
1410     return (ARCHIVE_FATAL);
1411   }
1412 }
1413 
1414 #elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1415 
1416 static int
1417 __archive_sha512init(archive_sha512_ctx *ctx)
1418 {
1419   sha512_init(ctx);
1420   return (ARCHIVE_OK);
1421 }
1422 
1423 static int
1424 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1425     size_t insize)
1426 {
1427   sha512_update(ctx, insize, indata);
1428   return (ARCHIVE_OK);
1429 }
1430 
1431 static int
1432 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1433 {
1434   sha512_digest(ctx, SHA512_DIGEST_SIZE, md);
1435   return (ARCHIVE_OK);
1436 }
1437 
1438 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1439 
1440 static int
1441 __archive_sha512init(archive_sha512_ctx *ctx)
1442 {
1443   if ((*ctx = EVP_MD_CTX_new()) == NULL)
1444 	return (ARCHIVE_FAILED);
1445   if (!EVP_DigestInit(*ctx, EVP_sha512()))
1446 	return (ARCHIVE_FAILED);
1447   return (ARCHIVE_OK);
1448 }
1449 
1450 static int
1451 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1452     size_t insize)
1453 {
1454   EVP_DigestUpdate(*ctx, indata, insize);
1455   return (ARCHIVE_OK);
1456 }
1457 
1458 static int
1459 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1460 {
1461   if (*ctx) {
1462     EVP_DigestFinal(*ctx, md, NULL);
1463     EVP_MD_CTX_free(*ctx);
1464     *ctx = NULL;
1465   }
1466   return (ARCHIVE_OK);
1467 }
1468 
1469 #elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1470 
1471 static int
1472 __archive_sha512init(archive_sha512_ctx *ctx)
1473 {
1474 #if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
1475   return (win_crypto_init(ctx, BCRYPT_SHA512_ALGORITHM));
1476 #else
1477   return (win_crypto_init(ctx, PROV_RSA_AES, CALG_SHA_512));
1478 #endif
1479 }
1480 
1481 static int
1482 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1483     size_t insize)
1484 {
1485   return (win_crypto_Update(ctx, indata, insize));
1486 }
1487 
1488 static int
1489 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1490 {
1491   return (win_crypto_Final(md, 64, ctx));
1492 }
1493 
1494 #else
1495 
1496 static int
1497 __archive_sha512init(archive_sha512_ctx *ctx)
1498 {
1499 	(void)ctx; /* UNUSED */
1500 	return (ARCHIVE_FAILED);
1501 }
1502 
1503 static int
1504 __archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1505     size_t insize)
1506 {
1507 	(void)ctx; /* UNUSED */
1508 	(void)indata; /* UNUSED */
1509 	(void)insize; /* UNUSED */
1510 	return (ARCHIVE_FAILED);
1511 }
1512 
1513 static int
1514 __archive_sha512final(archive_sha512_ctx *ctx, void *md)
1515 {
1516 	(void)ctx; /* UNUSED */
1517 	(void)md; /* UNUSED */
1518 	return (ARCHIVE_FAILED);
1519 }
1520 
1521 #endif
1522 
1523 /* NOTE: Message Digest functions are set based on availability and by the
1524  * following order of preference.
1525  * 1. libc
1526  * 2. libc2
1527  * 3. libc3
1528  * 4. libSystem
1529  * 5. Nettle
1530  * 6. OpenSSL
1531  * 7. libmd
1532  * 8. Windows API
1533  */
1534 const struct archive_digest __archive_digest =
1535 {
1536 /* MD5 */
1537   &__archive_md5init,
1538   &__archive_md5update,
1539   &__archive_md5final,
1540 
1541 /* RIPEMD160 */
1542   &__archive_ripemd160init,
1543   &__archive_ripemd160update,
1544   &__archive_ripemd160final,
1545 
1546 /* SHA1 */
1547   &__archive_sha1init,
1548   &__archive_sha1update,
1549   &__archive_sha1final,
1550 
1551 /* SHA256 */
1552   &__archive_sha256init,
1553   &__archive_sha256update,
1554   &__archive_sha256final,
1555 
1556 /* SHA384 */
1557   &__archive_sha384init,
1558   &__archive_sha384update,
1559   &__archive_sha384final,
1560 
1561 /* SHA512 */
1562   &__archive_sha512init,
1563   &__archive_sha512update,
1564   &__archive_sha512final
1565 };
1566