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