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