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_crypto_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 */
51static int
52win_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 */
77static int
78win_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
90static int
91win_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
111static int
112__archive_libc_md5init(archive_md5_ctx *ctx)
113{
114  MD5Init(ctx);
115  return (ARCHIVE_OK);
116}
117
118static int
119__archive_libc_md5update(archive_md5_ctx *ctx, const void *indata,
120    size_t insize)
121{
122  MD5Update(ctx, indata, insize);
123  return (ARCHIVE_OK);
124}
125
126static int
127__archive_libc_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
135static int
136__archive_libmd_md5init(archive_md5_ctx *ctx)
137{
138  MD5Init(ctx);
139  return (ARCHIVE_OK);
140}
141
142static int
143__archive_libmd_md5update(archive_md5_ctx *ctx, const void *indata,
144    size_t insize)
145{
146  MD5Update(ctx, indata, insize);
147  return (ARCHIVE_OK);
148}
149
150static int
151__archive_libmd_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
159static int
160__archive_libsystem_md5init(archive_md5_ctx *ctx)
161{
162  CC_MD5_Init(ctx);
163  return (ARCHIVE_OK);
164}
165
166static int
167__archive_libsystem_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
174static int
175__archive_libsystem_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_NETTLE)
182
183static int
184__archive_nettle_md5init(archive_md5_ctx *ctx)
185{
186  md5_init(ctx);
187  return (ARCHIVE_OK);
188}
189
190static int
191__archive_nettle_md5update(archive_md5_ctx *ctx, const void *indata,
192    size_t insize)
193{
194  md5_update(ctx, insize, indata);
195  return (ARCHIVE_OK);
196}
197
198static int
199__archive_nettle_md5final(archive_md5_ctx *ctx, void *md)
200{
201  md5_digest(ctx, MD5_DIGEST_SIZE, md);
202  return (ARCHIVE_OK);
203}
204
205#elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
206
207static int
208__archive_openssl_md5init(archive_md5_ctx *ctx)
209{
210  EVP_DigestInit(ctx, EVP_md5());
211  return (ARCHIVE_OK);
212}
213
214static int
215__archive_openssl_md5update(archive_md5_ctx *ctx, const void *indata,
216    size_t insize)
217{
218  EVP_DigestUpdate(ctx, indata, insize);
219  return (ARCHIVE_OK);
220}
221
222static int
223__archive_openssl_md5final(archive_md5_ctx *ctx, void *md)
224{
225  /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
226   * this is meant to cope with that. Real fix is probably to fix
227   * archive_write_set_format_xar.c
228   */
229  if (ctx->digest)
230    EVP_DigestFinal(ctx, md, NULL);
231  return (ARCHIVE_OK);
232}
233
234#elif defined(ARCHIVE_CRYPTO_MD5_WIN)
235
236static int
237__archive_windowsapi_md5init(archive_md5_ctx *ctx)
238{
239  return (win_crypto_init(ctx, CALG_MD5));
240}
241
242static int
243__archive_windowsapi_md5update(archive_md5_ctx *ctx, const void *indata,
244    size_t insize)
245{
246  return (win_crypto_Update(ctx, indata, insize));
247}
248
249static int
250__archive_windowsapi_md5final(archive_md5_ctx *ctx, void *md)
251{
252  return (win_crypto_Final(md, 16, ctx));
253}
254
255#else
256
257static int
258__archive_stub_md5init(archive_md5_ctx *ctx)
259{
260	(void)ctx; /* UNUSED */
261	return (ARCHIVE_FAILED);
262}
263
264static int
265__archive_stub_md5update(archive_md5_ctx *ctx, const void *indata,
266    size_t insize)
267{
268	(void)ctx; /* UNUSED */
269	(void)indata; /* UNUSED */
270	(void)insize; /* UNUSED */
271	return (ARCHIVE_FAILED);
272}
273
274static int
275__archive_stub_md5final(archive_md5_ctx *ctx, void *md)
276{
277	(void)ctx; /* UNUSED */
278	(void)md; /* UNUSED */
279	return (ARCHIVE_FAILED);
280}
281
282#endif
283
284/* RIPEMD160 implementations */
285#if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
286
287static int
288__archive_libc_ripemd160init(archive_rmd160_ctx *ctx)
289{
290  RMD160Init(ctx);
291  return (ARCHIVE_OK);
292}
293
294static int
295__archive_libc_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
296    size_t insize)
297{
298  RMD160Update(ctx, indata, insize);
299  return (ARCHIVE_OK);
300}
301
302static int
303__archive_libc_ripemd160final(archive_rmd160_ctx *ctx, void *md)
304{
305  RMD160Final(md, ctx);
306  return (ARCHIVE_OK);
307}
308
309#elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
310
311static int
312__archive_libmd_ripemd160init(archive_rmd160_ctx *ctx)
313{
314  RIPEMD160_Init(ctx);
315  return (ARCHIVE_OK);
316}
317
318static int
319__archive_libmd_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
320    size_t insize)
321{
322  RIPEMD160_Update(ctx, indata, insize);
323  return (ARCHIVE_OK);
324}
325
326static int
327__archive_libmd_ripemd160final(archive_rmd160_ctx *ctx, void *md)
328{
329  RIPEMD160_Final(md, ctx);
330  return (ARCHIVE_OK);
331}
332
333#elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
334
335static int
336__archive_nettle_ripemd160init(archive_rmd160_ctx *ctx)
337{
338  ripemd160_init(ctx);
339  return (ARCHIVE_OK);
340}
341
342static int
343__archive_nettle_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
344    size_t insize)
345{
346  ripemd160_update(ctx, insize, indata);
347  return (ARCHIVE_OK);
348}
349
350static int
351__archive_nettle_ripemd160final(archive_rmd160_ctx *ctx, void *md)
352{
353  ripemd160_digest(ctx, RIPEMD160_DIGEST_SIZE, md);
354  return (ARCHIVE_OK);
355}
356
357#elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
358
359static int
360__archive_openssl_ripemd160init(archive_rmd160_ctx *ctx)
361{
362  EVP_DigestInit(ctx, EVP_ripemd160());
363  return (ARCHIVE_OK);
364}
365
366static int
367__archive_openssl_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
368    size_t insize)
369{
370  EVP_DigestUpdate(ctx, indata, insize);
371  return (ARCHIVE_OK);
372}
373
374static int
375__archive_openssl_ripemd160final(archive_rmd160_ctx *ctx, void *md)
376{
377  EVP_DigestFinal(ctx, md, NULL);
378  return (ARCHIVE_OK);
379}
380
381#else
382
383static int
384__archive_stub_ripemd160init(archive_rmd160_ctx *ctx)
385{
386	(void)ctx; /* UNUSED */
387	return (ARCHIVE_FAILED);
388}
389
390static int
391__archive_stub_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
392    size_t insize)
393{
394	(void)ctx; /* UNUSED */
395	(void)indata; /* UNUSED */
396	(void)insize; /* UNUSED */
397	return (ARCHIVE_FAILED);
398}
399
400static int
401__archive_stub_ripemd160final(archive_rmd160_ctx *ctx, void *md)
402{
403	(void)ctx; /* UNUSED */
404	(void)md; /* UNUSED */
405	return (ARCHIVE_FAILED);
406}
407
408#endif
409
410/* SHA1 implementations */
411#if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
412
413static int
414__archive_libc_sha1init(archive_sha1_ctx *ctx)
415{
416  SHA1Init(ctx);
417  return (ARCHIVE_OK);
418}
419
420static int
421__archive_libc_sha1update(archive_sha1_ctx *ctx, const void *indata,
422    size_t insize)
423{
424  SHA1Update(ctx, indata, insize);
425  return (ARCHIVE_OK);
426}
427
428static int
429__archive_libc_sha1final(archive_sha1_ctx *ctx, void *md)
430{
431  SHA1Final(md, ctx);
432  return (ARCHIVE_OK);
433}
434
435#elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
436
437static int
438__archive_libmd_sha1init(archive_sha1_ctx *ctx)
439{
440  SHA1_Init(ctx);
441  return (ARCHIVE_OK);
442}
443
444static int
445__archive_libmd_sha1update(archive_sha1_ctx *ctx, const void *indata,
446    size_t insize)
447{
448  SHA1_Update(ctx, indata, insize);
449  return (ARCHIVE_OK);
450}
451
452static int
453__archive_libmd_sha1final(archive_sha1_ctx *ctx, void *md)
454{
455  SHA1_Final(md, ctx);
456  return (ARCHIVE_OK);
457}
458
459#elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
460
461static int
462__archive_libsystem_sha1init(archive_sha1_ctx *ctx)
463{
464  CC_SHA1_Init(ctx);
465  return (ARCHIVE_OK);
466}
467
468static int
469__archive_libsystem_sha1update(archive_sha1_ctx *ctx, const void *indata,
470    size_t insize)
471{
472  CC_SHA1_Update(ctx, indata, insize);
473  return (ARCHIVE_OK);
474}
475
476static int
477__archive_libsystem_sha1final(archive_sha1_ctx *ctx, void *md)
478{
479  CC_SHA1_Final(md, ctx);
480  return (ARCHIVE_OK);
481}
482
483#elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
484
485static int
486__archive_nettle_sha1init(archive_sha1_ctx *ctx)
487{
488  sha1_init(ctx);
489  return (ARCHIVE_OK);
490}
491
492static int
493__archive_nettle_sha1update(archive_sha1_ctx *ctx, const void *indata,
494    size_t insize)
495{
496  sha1_update(ctx, insize, indata);
497  return (ARCHIVE_OK);
498}
499
500static int
501__archive_nettle_sha1final(archive_sha1_ctx *ctx, void *md)
502{
503  sha1_digest(ctx, SHA1_DIGEST_SIZE, md);
504  return (ARCHIVE_OK);
505}
506
507#elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
508
509static int
510__archive_openssl_sha1init(archive_sha1_ctx *ctx)
511{
512  EVP_DigestInit(ctx, EVP_sha1());
513  return (ARCHIVE_OK);
514}
515
516static int
517__archive_openssl_sha1update(archive_sha1_ctx *ctx, const void *indata,
518    size_t insize)
519{
520  EVP_DigestUpdate(ctx, indata, insize);
521  return (ARCHIVE_OK);
522}
523
524static int
525__archive_openssl_sha1final(archive_sha1_ctx *ctx, void *md)
526{
527  /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
528   * this is meant to cope with that. Real fix is probably to fix
529   * archive_write_set_format_xar.c
530   */
531  if (ctx->digest)
532    EVP_DigestFinal(ctx, md, NULL);
533  return (ARCHIVE_OK);
534}
535
536#elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
537
538static int
539__archive_windowsapi_sha1init(archive_sha1_ctx *ctx)
540{
541  return (win_crypto_init(ctx, CALG_SHA1));
542}
543
544static int
545__archive_windowsapi_sha1update(archive_sha1_ctx *ctx, const void *indata,
546    size_t insize)
547{
548  return (win_crypto_Update(ctx, indata, insize));
549}
550
551static int
552__archive_windowsapi_sha1final(archive_sha1_ctx *ctx, void *md)
553{
554  return (win_crypto_Final(md, 20, ctx));
555}
556
557#else
558
559static int
560__archive_stub_sha1init(archive_sha1_ctx *ctx)
561{
562	(void)ctx; /* UNUSED */
563	return (ARCHIVE_FAILED);
564}
565
566static int
567__archive_stub_sha1update(archive_sha1_ctx *ctx, const void *indata,
568    size_t insize)
569{
570	(void)ctx; /* UNUSED */
571	(void)indata; /* UNUSED */
572	(void)insize; /* UNUSED */
573	return (ARCHIVE_FAILED);
574}
575
576static int
577__archive_stub_sha1final(archive_sha1_ctx *ctx, void *md)
578{
579	(void)ctx; /* UNUSED */
580	(void)md; /* UNUSED */
581	return (ARCHIVE_FAILED);
582}
583
584#endif
585
586/* SHA256 implementations */
587#if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
588
589static int
590__archive_libc_sha256init(archive_sha256_ctx *ctx)
591{
592  SHA256_Init(ctx);
593  return (ARCHIVE_OK);
594}
595
596static int
597__archive_libc_sha256update(archive_sha256_ctx *ctx, const void *indata,
598    size_t insize)
599{
600  SHA256_Update(ctx, indata, insize);
601  return (ARCHIVE_OK);
602}
603
604static int
605__archive_libc_sha256final(archive_sha256_ctx *ctx, void *md)
606{
607  SHA256_Final(md, ctx);
608  return (ARCHIVE_OK);
609}
610
611#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
612
613static int
614__archive_libc2_sha256init(archive_sha256_ctx *ctx)
615{
616  SHA256Init(ctx);
617  return (ARCHIVE_OK);
618}
619
620static int
621__archive_libc2_sha256update(archive_sha256_ctx *ctx, const void *indata,
622    size_t insize)
623{
624  SHA256Update(ctx, indata, insize);
625  return (ARCHIVE_OK);
626}
627
628static int
629__archive_libc2_sha256final(archive_sha256_ctx *ctx, void *md)
630{
631  SHA256Final(md, ctx);
632  return (ARCHIVE_OK);
633}
634
635#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
636
637static int
638__archive_libc3_sha256init(archive_sha256_ctx *ctx)
639{
640  SHA256Init(ctx);
641  return (ARCHIVE_OK);
642}
643
644static int
645__archive_libc3_sha256update(archive_sha256_ctx *ctx, const void *indata,
646    size_t insize)
647{
648  SHA256Update(ctx, indata, insize);
649  return (ARCHIVE_OK);
650}
651
652static int
653__archive_libc3_sha256final(archive_sha256_ctx *ctx, void *md)
654{
655  SHA256Final(md, ctx);
656  return (ARCHIVE_OK);
657}
658
659#elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
660
661static int
662__archive_libmd_sha256init(archive_sha256_ctx *ctx)
663{
664  SHA256_Init(ctx);
665  return (ARCHIVE_OK);
666}
667
668static int
669__archive_libmd_sha256update(archive_sha256_ctx *ctx, const void *indata,
670    size_t insize)
671{
672  SHA256_Update(ctx, indata, insize);
673  return (ARCHIVE_OK);
674}
675
676static int
677__archive_libmd_sha256final(archive_sha256_ctx *ctx, void *md)
678{
679  SHA256_Final(md, ctx);
680  return (ARCHIVE_OK);
681}
682
683#elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
684
685static int
686__archive_libsystem_sha256init(archive_sha256_ctx *ctx)
687{
688  CC_SHA256_Init(ctx);
689  return (ARCHIVE_OK);
690}
691
692static int
693__archive_libsystem_sha256update(archive_sha256_ctx *ctx, const void *indata,
694    size_t insize)
695{
696  CC_SHA256_Update(ctx, indata, insize);
697  return (ARCHIVE_OK);
698}
699
700static int
701__archive_libsystem_sha256final(archive_sha256_ctx *ctx, void *md)
702{
703  CC_SHA256_Final(md, ctx);
704  return (ARCHIVE_OK);
705}
706
707#elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
708
709static int
710__archive_nettle_sha256init(archive_sha256_ctx *ctx)
711{
712  sha256_init(ctx);
713  return (ARCHIVE_OK);
714}
715
716static int
717__archive_nettle_sha256update(archive_sha256_ctx *ctx, const void *indata,
718    size_t insize)
719{
720  sha256_update(ctx, insize, indata);
721  return (ARCHIVE_OK);
722}
723
724static int
725__archive_nettle_sha256final(archive_sha256_ctx *ctx, void *md)
726{
727  sha256_digest(ctx, SHA256_DIGEST_SIZE, md);
728  return (ARCHIVE_OK);
729}
730
731#elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
732
733static int
734__archive_openssl_sha256init(archive_sha256_ctx *ctx)
735{
736  EVP_DigestInit(ctx, EVP_sha256());
737  return (ARCHIVE_OK);
738}
739
740static int
741__archive_openssl_sha256update(archive_sha256_ctx *ctx, const void *indata,
742    size_t insize)
743{
744  EVP_DigestUpdate(ctx, indata, insize);
745  return (ARCHIVE_OK);
746}
747
748static int
749__archive_openssl_sha256final(archive_sha256_ctx *ctx, void *md)
750{
751  EVP_DigestFinal(ctx, md, NULL);
752  return (ARCHIVE_OK);
753}
754
755#elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
756
757static int
758__archive_windowsapi_sha256init(archive_sha256_ctx *ctx)
759{
760  return (win_crypto_init(ctx, CALG_SHA_256));
761}
762
763static int
764__archive_windowsapi_sha256update(archive_sha256_ctx *ctx, const void *indata,
765    size_t insize)
766{
767  return (win_crypto_Update(ctx, indata, insize));
768}
769
770static int
771__archive_windowsapi_sha256final(archive_sha256_ctx *ctx, void *md)
772{
773  return (win_crypto_Final(md, 32, ctx));
774}
775
776#else
777
778static int
779__archive_stub_sha256init(archive_sha256_ctx *ctx)
780{
781	(void)ctx; /* UNUSED */
782	return (ARCHIVE_FAILED);
783}
784
785static int
786__archive_stub_sha256update(archive_sha256_ctx *ctx, const void *indata,
787    size_t insize)
788{
789	(void)ctx; /* UNUSED */
790	(void)indata; /* UNUSED */
791	(void)insize; /* UNUSED */
792	return (ARCHIVE_FAILED);
793}
794
795static int
796__archive_stub_sha256final(archive_sha256_ctx *ctx, void *md)
797{
798	(void)ctx; /* UNUSED */
799	(void)md; /* UNUSED */
800	return (ARCHIVE_FAILED);
801}
802
803#endif
804
805/* SHA384 implementations */
806#if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
807
808static int
809__archive_libc_sha384init(archive_sha384_ctx *ctx)
810{
811  SHA384_Init(ctx);
812  return (ARCHIVE_OK);
813}
814
815static int
816__archive_libc_sha384update(archive_sha384_ctx *ctx, const void *indata,
817    size_t insize)
818{
819  SHA384_Update(ctx, indata, insize);
820  return (ARCHIVE_OK);
821}
822
823static int
824__archive_libc_sha384final(archive_sha384_ctx *ctx, void *md)
825{
826  SHA384_Final(md, ctx);
827  return (ARCHIVE_OK);
828}
829
830#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
831
832static int
833__archive_libc2_sha384init(archive_sha384_ctx *ctx)
834{
835  SHA384Init(ctx);
836  return (ARCHIVE_OK);
837}
838
839static int
840__archive_libc2_sha384update(archive_sha384_ctx *ctx, const void *indata,
841    size_t insize)
842{
843  SHA384Update(ctx, indata, insize);
844  return (ARCHIVE_OK);
845}
846
847static int
848__archive_libc2_sha384final(archive_sha384_ctx *ctx, void *md)
849{
850  SHA384Final(md, ctx);
851  return (ARCHIVE_OK);
852}
853
854#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
855
856static int
857__archive_libc3_sha384init(archive_sha384_ctx *ctx)
858{
859  SHA384Init(ctx);
860  return (ARCHIVE_OK);
861}
862
863static int
864__archive_libc3_sha384update(archive_sha384_ctx *ctx, const void *indata,
865    size_t insize)
866{
867  SHA384Update(ctx, indata, insize);
868  return (ARCHIVE_OK);
869}
870
871static int
872__archive_libc3_sha384final(archive_sha384_ctx *ctx, void *md)
873{
874  SHA384Final(md, ctx);
875  return (ARCHIVE_OK);
876}
877
878#elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
879
880static int
881__archive_libsystem_sha384init(archive_sha384_ctx *ctx)
882{
883  CC_SHA384_Init(ctx);
884  return (ARCHIVE_OK);
885}
886
887static int
888__archive_libsystem_sha384update(archive_sha384_ctx *ctx, const void *indata,
889    size_t insize)
890{
891  CC_SHA384_Update(ctx, indata, insize);
892  return (ARCHIVE_OK);
893}
894
895static int
896__archive_libsystem_sha384final(archive_sha384_ctx *ctx, void *md)
897{
898  CC_SHA384_Final(md, ctx);
899  return (ARCHIVE_OK);
900}
901
902#elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
903
904static int
905__archive_nettle_sha384init(archive_sha384_ctx *ctx)
906{
907  sha384_init(ctx);
908  return (ARCHIVE_OK);
909}
910
911static int
912__archive_nettle_sha384update(archive_sha384_ctx *ctx, const void *indata,
913    size_t insize)
914{
915  sha384_update(ctx, insize, indata);
916  return (ARCHIVE_OK);
917}
918
919static int
920__archive_nettle_sha384final(archive_sha384_ctx *ctx, void *md)
921{
922  sha384_digest(ctx, SHA384_DIGEST_SIZE, md);
923  return (ARCHIVE_OK);
924}
925
926#elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
927
928static int
929__archive_openssl_sha384init(archive_sha384_ctx *ctx)
930{
931  EVP_DigestInit(ctx, EVP_sha384());
932  return (ARCHIVE_OK);
933}
934
935static int
936__archive_openssl_sha384update(archive_sha384_ctx *ctx, const void *indata,
937    size_t insize)
938{
939  EVP_DigestUpdate(ctx, indata, insize);
940  return (ARCHIVE_OK);
941}
942
943static int
944__archive_openssl_sha384final(archive_sha384_ctx *ctx, void *md)
945{
946  EVP_DigestFinal(ctx, md, NULL);
947  return (ARCHIVE_OK);
948}
949
950#elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
951
952static int
953__archive_windowsapi_sha384init(archive_sha384_ctx *ctx)
954{
955  return (win_crypto_init(ctx, CALG_SHA_384));
956}
957
958static int
959__archive_windowsapi_sha384update(archive_sha384_ctx *ctx, const void *indata,
960    size_t insize)
961{
962  return (win_crypto_Update(ctx, indata, insize));
963}
964
965static int
966__archive_windowsapi_sha384final(archive_sha384_ctx *ctx, void *md)
967{
968  return (win_crypto_Final(md, 48, ctx));
969}
970
971#else
972
973static int
974__archive_stub_sha384init(archive_sha384_ctx *ctx)
975{
976	(void)ctx; /* UNUSED */
977	return (ARCHIVE_FAILED);
978}
979
980static int
981__archive_stub_sha384update(archive_sha384_ctx *ctx, const void *indata,
982    size_t insize)
983{
984	(void)ctx; /* UNUSED */
985	(void)indata; /* UNUSED */
986	(void)insize; /* UNUSED */
987	return (ARCHIVE_FAILED);
988}
989
990static int
991__archive_stub_sha384final(archive_sha384_ctx *ctx, void *md)
992{
993	(void)ctx; /* UNUSED */
994	(void)md; /* UNUSED */
995	return (ARCHIVE_FAILED);
996}
997
998#endif
999
1000/* SHA512 implementations */
1001#if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1002
1003static int
1004__archive_libc_sha512init(archive_sha512_ctx *ctx)
1005{
1006  SHA512_Init(ctx);
1007  return (ARCHIVE_OK);
1008}
1009
1010static int
1011__archive_libc_sha512update(archive_sha512_ctx *ctx, const void *indata,
1012    size_t insize)
1013{
1014  SHA512_Update(ctx, indata, insize);
1015  return (ARCHIVE_OK);
1016}
1017
1018static int
1019__archive_libc_sha512final(archive_sha512_ctx *ctx, void *md)
1020{
1021  SHA512_Final(md, ctx);
1022  return (ARCHIVE_OK);
1023}
1024
1025#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1026
1027static int
1028__archive_libc2_sha512init(archive_sha512_ctx *ctx)
1029{
1030  SHA512Init(ctx);
1031  return (ARCHIVE_OK);
1032}
1033
1034static int
1035__archive_libc2_sha512update(archive_sha512_ctx *ctx, const void *indata,
1036    size_t insize)
1037{
1038  SHA512Update(ctx, indata, insize);
1039  return (ARCHIVE_OK);
1040}
1041
1042static int
1043__archive_libc2_sha512final(archive_sha512_ctx *ctx, void *md)
1044{
1045  SHA512Final(md, ctx);
1046  return (ARCHIVE_OK);
1047}
1048
1049#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1050
1051static int
1052__archive_libc3_sha512init(archive_sha512_ctx *ctx)
1053{
1054  SHA512Init(ctx);
1055  return (ARCHIVE_OK);
1056}
1057
1058static int
1059__archive_libc3_sha512update(archive_sha512_ctx *ctx, const void *indata,
1060    size_t insize)
1061{
1062  SHA512Update(ctx, indata, insize);
1063  return (ARCHIVE_OK);
1064}
1065
1066static int
1067__archive_libc3_sha512final(archive_sha512_ctx *ctx, void *md)
1068{
1069  SHA512Final(md, ctx);
1070  return (ARCHIVE_OK);
1071}
1072
1073#elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1074
1075static int
1076__archive_libmd_sha512init(archive_sha512_ctx *ctx)
1077{
1078  SHA512_Init(ctx);
1079  return (ARCHIVE_OK);
1080}
1081
1082static int
1083__archive_libmd_sha512update(archive_sha512_ctx *ctx, const void *indata,
1084    size_t insize)
1085{
1086  SHA512_Update(ctx, indata, insize);
1087  return (ARCHIVE_OK);
1088}
1089
1090static int
1091__archive_libmd_sha512final(archive_sha512_ctx *ctx, void *md)
1092{
1093  SHA512_Final(md, ctx);
1094  return (ARCHIVE_OK);
1095}
1096
1097#elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1098
1099static int
1100__archive_libsystem_sha512init(archive_sha512_ctx *ctx)
1101{
1102  CC_SHA512_Init(ctx);
1103  return (ARCHIVE_OK);
1104}
1105
1106static int
1107__archive_libsystem_sha512update(archive_sha512_ctx *ctx, const void *indata,
1108    size_t insize)
1109{
1110  CC_SHA512_Update(ctx, indata, insize);
1111  return (ARCHIVE_OK);
1112}
1113
1114static int
1115__archive_libsystem_sha512final(archive_sha512_ctx *ctx, void *md)
1116{
1117  CC_SHA512_Final(md, ctx);
1118  return (ARCHIVE_OK);
1119}
1120
1121#elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1122
1123static int
1124__archive_nettle_sha512init(archive_sha512_ctx *ctx)
1125{
1126  sha512_init(ctx);
1127  return (ARCHIVE_OK);
1128}
1129
1130static int
1131__archive_nettle_sha512update(archive_sha512_ctx *ctx, const void *indata,
1132    size_t insize)
1133{
1134  sha512_update(ctx, insize, indata);
1135  return (ARCHIVE_OK);
1136}
1137
1138static int
1139__archive_nettle_sha512final(archive_sha512_ctx *ctx, void *md)
1140{
1141  sha512_digest(ctx, SHA512_DIGEST_SIZE, md);
1142  return (ARCHIVE_OK);
1143}
1144
1145#elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1146
1147static int
1148__archive_openssl_sha512init(archive_sha512_ctx *ctx)
1149{
1150  EVP_DigestInit(ctx, EVP_sha512());
1151  return (ARCHIVE_OK);
1152}
1153
1154static int
1155__archive_openssl_sha512update(archive_sha512_ctx *ctx, const void *indata,
1156    size_t insize)
1157{
1158  EVP_DigestUpdate(ctx, indata, insize);
1159  return (ARCHIVE_OK);
1160}
1161
1162static int
1163__archive_openssl_sha512final(archive_sha512_ctx *ctx, void *md)
1164{
1165  EVP_DigestFinal(ctx, md, NULL);
1166  return (ARCHIVE_OK);
1167}
1168
1169#elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1170
1171static int
1172__archive_windowsapi_sha512init(archive_sha512_ctx *ctx)
1173{
1174  return (win_crypto_init(ctx, CALG_SHA_512));
1175}
1176
1177static int
1178__archive_windowsapi_sha512update(archive_sha512_ctx *ctx, const void *indata,
1179    size_t insize)
1180{
1181  return (win_crypto_Update(ctx, indata, insize));
1182}
1183
1184static int
1185__archive_windowsapi_sha512final(archive_sha512_ctx *ctx, void *md)
1186{
1187  return (win_crypto_Final(md, 64, ctx));
1188}
1189
1190#else
1191
1192static int
1193__archive_stub_sha512init(archive_sha512_ctx *ctx)
1194{
1195	(void)ctx; /* UNUSED */
1196	return (ARCHIVE_FAILED);
1197}
1198
1199static int
1200__archive_stub_sha512update(archive_sha512_ctx *ctx, const void *indata,
1201    size_t insize)
1202{
1203	(void)ctx; /* UNUSED */
1204	(void)indata; /* UNUSED */
1205	(void)insize; /* UNUSED */
1206	return (ARCHIVE_FAILED);
1207}
1208
1209static int
1210__archive_stub_sha512final(archive_sha512_ctx *ctx, void *md)
1211{
1212	(void)ctx; /* UNUSED */
1213	(void)md; /* UNUSED */
1214	return (ARCHIVE_FAILED);
1215}
1216
1217#endif
1218
1219/* NOTE: Crypto functions are set based on availability and by the following
1220 * order of preference.
1221 * 1. libc
1222 * 2. libc2
1223 * 3. libc3
1224 * 4. libSystem
1225 * 5. Nettle
1226 * 6. OpenSSL
1227 * 7. libmd
1228 * 8. Windows API
1229 */
1230const struct archive_crypto __archive_crypto =
1231{
1232/* MD5 */
1233#if defined(ARCHIVE_CRYPTO_MD5_LIBC)
1234  &__archive_libc_md5init,
1235  &__archive_libc_md5update,
1236  &__archive_libc_md5final,
1237#elif defined(ARCHIVE_CRYPTO_MD5_LIBMD)
1238  &__archive_libmd_md5init,
1239  &__archive_libmd_md5update,
1240  &__archive_libmd_md5final,
1241#elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM)
1242  &__archive_libsystem_md5init,
1243  &__archive_libsystem_md5update,
1244  &__archive_libsystem_md5final,
1245#elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
1246  &__archive_nettle_md5init,
1247  &__archive_nettle_md5update,
1248  &__archive_nettle_md5final,
1249#elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
1250  &__archive_openssl_md5init,
1251  &__archive_openssl_md5update,
1252  &__archive_openssl_md5final,
1253#elif defined(ARCHIVE_CRYPTO_MD5_WIN)
1254  &__archive_windowsapi_md5init,
1255  &__archive_windowsapi_md5update,
1256  &__archive_windowsapi_md5final,
1257#elif !defined(ARCHIVE_MD5_COMPILE_TEST)
1258  &__archive_stub_md5init,
1259  &__archive_stub_md5update,
1260  &__archive_stub_md5final,
1261#endif
1262
1263/* RIPEMD160 */
1264#if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
1265  &__archive_libc_ripemd160init,
1266  &__archive_libc_ripemd160update,
1267  &__archive_libc_ripemd160final,
1268#elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
1269  &__archive_libmd_ripemd160init,
1270  &__archive_libmd_ripemd160update,
1271  &__archive_libmd_ripemd160final,
1272#elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
1273  &__archive_nettle_ripemd160init,
1274  &__archive_nettle_ripemd160update,
1275  &__archive_nettle_ripemd160final,
1276#elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
1277  &__archive_openssl_ripemd160init,
1278  &__archive_openssl_ripemd160update,
1279  &__archive_openssl_ripemd160final,
1280#elif !defined(ARCHIVE_RMD160_COMPILE_TEST)
1281  &__archive_stub_ripemd160init,
1282  &__archive_stub_ripemd160update,
1283  &__archive_stub_ripemd160final,
1284#endif
1285
1286/* SHA1 */
1287#if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
1288  &__archive_libc_sha1init,
1289  &__archive_libc_sha1update,
1290  &__archive_libc_sha1final,
1291#elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
1292  &__archive_libmd_sha1init,
1293  &__archive_libmd_sha1update,
1294  &__archive_libmd_sha1final,
1295#elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
1296  &__archive_libsystem_sha1init,
1297  &__archive_libsystem_sha1update,
1298  &__archive_libsystem_sha1final,
1299#elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
1300  &__archive_nettle_sha1init,
1301  &__archive_nettle_sha1update,
1302  &__archive_nettle_sha1final,
1303#elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
1304  &__archive_openssl_sha1init,
1305  &__archive_openssl_sha1update,
1306  &__archive_openssl_sha1final,
1307#elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
1308  &__archive_windowsapi_sha1init,
1309  &__archive_windowsapi_sha1update,
1310  &__archive_windowsapi_sha1final,
1311#elif !defined(ARCHIVE_SHA1_COMPILE_TEST)
1312  &__archive_stub_sha1init,
1313  &__archive_stub_sha1update,
1314  &__archive_stub_sha1final,
1315#endif
1316
1317/* SHA256 */
1318#if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
1319  &__archive_libc_sha256init,
1320  &__archive_libc_sha256update,
1321  &__archive_libc_sha256final,
1322#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
1323  &__archive_libc2_sha256init,
1324  &__archive_libc2_sha256update,
1325  &__archive_libc2_sha256final,
1326#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
1327  &__archive_libc3_sha256init,
1328  &__archive_libc3_sha256update,
1329  &__archive_libc3_sha256final,
1330#elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
1331  &__archive_libmd_sha256init,
1332  &__archive_libmd_sha256update,
1333  &__archive_libmd_sha256final,
1334#elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
1335  &__archive_libsystem_sha256init,
1336  &__archive_libsystem_sha256update,
1337  &__archive_libsystem_sha256final,
1338#elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
1339  &__archive_nettle_sha256init,
1340  &__archive_nettle_sha256update,
1341  &__archive_nettle_sha256final,
1342#elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
1343  &__archive_openssl_sha256init,
1344  &__archive_openssl_sha256update,
1345  &__archive_openssl_sha256final,
1346#elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
1347  &__archive_windowsapi_sha256init,
1348  &__archive_windowsapi_sha256update,
1349  &__archive_windowsapi_sha256final,
1350#elif !defined(ARCHIVE_SHA256_COMPILE_TEST)
1351  &__archive_stub_sha256init,
1352  &__archive_stub_sha256update,
1353  &__archive_stub_sha256final,
1354#endif
1355
1356/* SHA384 */
1357#if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
1358  &__archive_libc_sha384init,
1359  &__archive_libc_sha384update,
1360  &__archive_libc_sha384final,
1361#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
1362  &__archive_libc2_sha384init,
1363  &__archive_libc2_sha384update,
1364  &__archive_libc2_sha384final,
1365#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
1366  &__archive_libc3_sha384init,
1367  &__archive_libc3_sha384update,
1368  &__archive_libc3_sha384final,
1369#elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
1370  &__archive_libsystem_sha384init,
1371  &__archive_libsystem_sha384update,
1372  &__archive_libsystem_sha384final,
1373#elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
1374  &__archive_nettle_sha384init,
1375  &__archive_nettle_sha384update,
1376  &__archive_nettle_sha384final,
1377#elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
1378  &__archive_openssl_sha384init,
1379  &__archive_openssl_sha384update,
1380  &__archive_openssl_sha384final,
1381#elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
1382  &__archive_windowsapi_sha384init,
1383  &__archive_windowsapi_sha384update,
1384  &__archive_windowsapi_sha384final,
1385#elif !defined(ARCHIVE_SHA384_COMPILE_TEST)
1386  &__archive_stub_sha384init,
1387  &__archive_stub_sha384update,
1388  &__archive_stub_sha384final,
1389#endif
1390
1391/* SHA512 */
1392#if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1393  &__archive_libc_sha512init,
1394  &__archive_libc_sha512update,
1395  &__archive_libc_sha512final
1396#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1397  &__archive_libc2_sha512init,
1398  &__archive_libc2_sha512update,
1399  &__archive_libc2_sha512final
1400#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1401  &__archive_libc3_sha512init,
1402  &__archive_libc3_sha512update,
1403  &__archive_libc3_sha512final
1404#elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1405  &__archive_libmd_sha512init,
1406  &__archive_libmd_sha512update,
1407  &__archive_libmd_sha512final
1408#elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1409  &__archive_libsystem_sha512init,
1410  &__archive_libsystem_sha512update,
1411  &__archive_libsystem_sha512final
1412#elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1413  &__archive_nettle_sha512init,
1414  &__archive_nettle_sha512update,
1415  &__archive_nettle_sha512final,
1416#elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1417  &__archive_openssl_sha512init,
1418  &__archive_openssl_sha512update,
1419  &__archive_openssl_sha512final
1420#elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1421  &__archive_windowsapi_sha512init,
1422  &__archive_windowsapi_sha512update,
1423  &__archive_windowsapi_sha512final
1424#elif !defined(ARCHIVE_SHA512_COMPILE_TEST)
1425  &__archive_stub_sha512init,
1426  &__archive_stub_sha512update,
1427  &__archive_stub_sha512final
1428#endif
1429};
1430