archive_digest.c revision 358088 
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 */
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_MBEDTLS)
182
183static int
184__archive_mbedtls_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
193static int
194__archive_mbedtls_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
203static int
204__archive_mbedtls_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
217static int
218__archive_nettle_md5init(archive_md5_ctx *ctx)
219{
220  md5_init(ctx);
221  return (ARCHIVE_OK);
222}
223
224static int
225__archive_nettle_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
232static int
233__archive_nettle_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
241static int
242__archive_openssl_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
250static int
251__archive_openssl_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
258static int
259__archive_openssl_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
275static int
276__archive_windowsapi_md5init(archive_md5_ctx *ctx)
277{
278  return (win_crypto_init(ctx, CALG_MD5));
279}
280
281static int
282__archive_windowsapi_md5update(archive_md5_ctx *ctx, const void *indata,
283    size_t insize)
284{
285  return (win_crypto_Update(ctx, indata, insize));
286}
287
288static int
289__archive_windowsapi_md5final(archive_md5_ctx *ctx, void *md)
290{
291  return (win_crypto_Final(md, 16, ctx));
292}
293
294#else
295
296static int
297__archive_stub_md5init(archive_md5_ctx *ctx)
298{
299	(void)ctx; /* UNUSED */
300	return (ARCHIVE_FAILED);
301}
302
303static int
304__archive_stub_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
313static int
314__archive_stub_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
326static int
327__archive_libc_ripemd160init(archive_rmd160_ctx *ctx)
328{
329  RMD160Init(ctx);
330  return (ARCHIVE_OK);
331}
332
333static int
334__archive_libc_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
335    size_t insize)
336{
337  RMD160Update(ctx, indata, insize);
338  return (ARCHIVE_OK);
339}
340
341static int
342__archive_libc_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
350static int
351__archive_libmd_ripemd160init(archive_rmd160_ctx *ctx)
352{
353  RIPEMD160_Init(ctx);
354  return (ARCHIVE_OK);
355}
356
357static int
358__archive_libmd_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
365static int
366__archive_libmd_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
374static int
375__archive_mbedtls_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
384static int
385__archive_mbedtls_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
394static int
395__archive_mbedtls_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
408static int
409__archive_nettle_ripemd160init(archive_rmd160_ctx *ctx)
410{
411  ripemd160_init(ctx);
412  return (ARCHIVE_OK);
413}
414
415static int
416__archive_nettle_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
423static int
424__archive_nettle_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
432static int
433__archive_openssl_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
441static int
442__archive_openssl_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
449static int
450__archive_openssl_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
462static int
463__archive_stub_ripemd160init(archive_rmd160_ctx *ctx)
464{
465	(void)ctx; /* UNUSED */
466	return (ARCHIVE_FAILED);
467}
468
469static int
470__archive_stub_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
479static int
480__archive_stub_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
492static int
493__archive_libc_sha1init(archive_sha1_ctx *ctx)
494{
495  SHA1Init(ctx);
496  return (ARCHIVE_OK);
497}
498
499static int
500__archive_libc_sha1update(archive_sha1_ctx *ctx, const void *indata,
501    size_t insize)
502{
503  SHA1Update(ctx, indata, insize);
504  return (ARCHIVE_OK);
505}
506
507static int
508__archive_libc_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
516static int
517__archive_libmd_sha1init(archive_sha1_ctx *ctx)
518{
519  SHA1_Init(ctx);
520  return (ARCHIVE_OK);
521}
522
523static int
524__archive_libmd_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
531static int
532__archive_libmd_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
540static int
541__archive_libsystem_sha1init(archive_sha1_ctx *ctx)
542{
543  CC_SHA1_Init(ctx);
544  return (ARCHIVE_OK);
545}
546
547static int
548__archive_libsystem_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
555static int
556__archive_libsystem_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
564static int
565__archive_mbedtls_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
574static int
575__archive_mbedtls_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
584static int
585__archive_mbedtls_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
598static int
599__archive_nettle_sha1init(archive_sha1_ctx *ctx)
600{
601  sha1_init(ctx);
602  return (ARCHIVE_OK);
603}
604
605static int
606__archive_nettle_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
613static int
614__archive_nettle_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
622static int
623__archive_openssl_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
631static int
632__archive_openssl_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
639static int
640__archive_openssl_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
656static int
657__archive_windowsapi_sha1init(archive_sha1_ctx *ctx)
658{
659  return (win_crypto_init(ctx, CALG_SHA1));
660}
661
662static int
663__archive_windowsapi_sha1update(archive_sha1_ctx *ctx, const void *indata,
664    size_t insize)
665{
666  return (win_crypto_Update(ctx, indata, insize));
667}
668
669static int
670__archive_windowsapi_sha1final(archive_sha1_ctx *ctx, void *md)
671{
672  return (win_crypto_Final(md, 20, ctx));
673}
674
675#else
676
677static int
678__archive_stub_sha1init(archive_sha1_ctx *ctx)
679{
680	(void)ctx; /* UNUSED */
681	return (ARCHIVE_FAILED);
682}
683
684static int
685__archive_stub_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
694static int
695__archive_stub_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
707static int
708__archive_libc_sha256init(archive_sha256_ctx *ctx)
709{
710  SHA256_Init(ctx);
711  return (ARCHIVE_OK);
712}
713
714static int
715__archive_libc_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
722static int
723__archive_libc_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
731static int
732__archive_libc2_sha256init(archive_sha256_ctx *ctx)
733{
734  SHA256Init(ctx);
735  return (ARCHIVE_OK);
736}
737
738static int
739__archive_libc2_sha256update(archive_sha256_ctx *ctx, const void *indata,
740    size_t insize)
741{
742  SHA256Update(ctx, indata, insize);
743  return (ARCHIVE_OK);
744}
745
746static int
747__archive_libc2_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
755static int
756__archive_libc3_sha256init(archive_sha256_ctx *ctx)
757{
758  SHA256Init(ctx);
759  return (ARCHIVE_OK);
760}
761
762static int
763__archive_libc3_sha256update(archive_sha256_ctx *ctx, const void *indata,
764    size_t insize)
765{
766  SHA256Update(ctx, indata, insize);
767  return (ARCHIVE_OK);
768}
769
770static int
771__archive_libc3_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
779static int
780__archive_libmd_sha256init(archive_sha256_ctx *ctx)
781{
782  SHA256_Init(ctx);
783  return (ARCHIVE_OK);
784}
785
786static int
787__archive_libmd_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
794static int
795__archive_libmd_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
803static int
804__archive_libsystem_sha256init(archive_sha256_ctx *ctx)
805{
806  CC_SHA256_Init(ctx);
807  return (ARCHIVE_OK);
808}
809
810static int
811__archive_libsystem_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
818static int
819__archive_libsystem_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
827static int
828__archive_mbedtls_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
837static int
838__archive_mbedtls_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
847static int
848__archive_mbedtls_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
861static int
862__archive_nettle_sha256init(archive_sha256_ctx *ctx)
863{
864  sha256_init(ctx);
865  return (ARCHIVE_OK);
866}
867
868static int
869__archive_nettle_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
876static int
877__archive_nettle_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
885static int
886__archive_openssl_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
894static int
895__archive_openssl_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
902static int
903__archive_openssl_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
915static int
916__archive_windowsapi_sha256init(archive_sha256_ctx *ctx)
917{
918  return (win_crypto_init(ctx, CALG_SHA_256));
919}
920
921static int
922__archive_windowsapi_sha256update(archive_sha256_ctx *ctx, const void *indata,
923    size_t insize)
924{
925  return (win_crypto_Update(ctx, indata, insize));
926}
927
928static int
929__archive_windowsapi_sha256final(archive_sha256_ctx *ctx, void *md)
930{
931  return (win_crypto_Final(md, 32, ctx));
932}
933
934#else
935
936static int
937__archive_stub_sha256init(archive_sha256_ctx *ctx)
938{
939	(void)ctx; /* UNUSED */
940	return (ARCHIVE_FAILED);
941}
942
943static int
944__archive_stub_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
953static int
954__archive_stub_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
966static int
967__archive_libc_sha384init(archive_sha384_ctx *ctx)
968{
969  SHA384_Init(ctx);
970  return (ARCHIVE_OK);
971}
972
973static int
974__archive_libc_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
981static int
982__archive_libc_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
990static int
991__archive_libc2_sha384init(archive_sha384_ctx *ctx)
992{
993  SHA384Init(ctx);
994  return (ARCHIVE_OK);
995}
996
997static int
998__archive_libc2_sha384update(archive_sha384_ctx *ctx, const void *indata,
999    size_t insize)
1000{
1001  SHA384Update(ctx, indata, insize);
1002  return (ARCHIVE_OK);
1003}
1004
1005static int
1006__archive_libc2_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
1014static int
1015__archive_libc3_sha384init(archive_sha384_ctx *ctx)
1016{
1017  SHA384Init(ctx);
1018  return (ARCHIVE_OK);
1019}
1020
1021static int
1022__archive_libc3_sha384update(archive_sha384_ctx *ctx, const void *indata,
1023    size_t insize)
1024{
1025  SHA384Update(ctx, indata, insize);
1026  return (ARCHIVE_OK);
1027}
1028
1029static int
1030__archive_libc3_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
1038static int
1039__archive_libsystem_sha384init(archive_sha384_ctx *ctx)
1040{
1041  CC_SHA384_Init(ctx);
1042  return (ARCHIVE_OK);
1043}
1044
1045static int
1046__archive_libsystem_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
1053static int
1054__archive_libsystem_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
1062static int
1063__archive_mbedtls_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
1072static int
1073__archive_mbedtls_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
1082static int
1083__archive_mbedtls_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
1096static int
1097__archive_nettle_sha384init(archive_sha384_ctx *ctx)
1098{
1099  sha384_init(ctx);
1100  return (ARCHIVE_OK);
1101}
1102
1103static int
1104__archive_nettle_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
1111static int
1112__archive_nettle_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
1120static int
1121__archive_openssl_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
1129static int
1130__archive_openssl_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
1137static int
1138__archive_openssl_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
1150static int
1151__archive_windowsapi_sha384init(archive_sha384_ctx *ctx)
1152{
1153  return (win_crypto_init(ctx, CALG_SHA_384));
1154}
1155
1156static int
1157__archive_windowsapi_sha384update(archive_sha384_ctx *ctx, const void *indata,
1158    size_t insize)
1159{
1160  return (win_crypto_Update(ctx, indata, insize));
1161}
1162
1163static int
1164__archive_windowsapi_sha384final(archive_sha384_ctx *ctx, void *md)
1165{
1166  return (win_crypto_Final(md, 48, ctx));
1167}
1168
1169#else
1170
1171static int
1172__archive_stub_sha384init(archive_sha384_ctx *ctx)
1173{
1174	(void)ctx; /* UNUSED */
1175	return (ARCHIVE_FAILED);
1176}
1177
1178static int
1179__archive_stub_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
1188static int
1189__archive_stub_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
1201static int
1202__archive_libc_sha512init(archive_sha512_ctx *ctx)
1203{
1204  SHA512_Init(ctx);
1205  return (ARCHIVE_OK);
1206}
1207
1208static int
1209__archive_libc_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
1216static int
1217__archive_libc_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
1225static int
1226__archive_libc2_sha512init(archive_sha512_ctx *ctx)
1227{
1228  SHA512Init(ctx);
1229  return (ARCHIVE_OK);
1230}
1231
1232static int
1233__archive_libc2_sha512update(archive_sha512_ctx *ctx, const void *indata,
1234    size_t insize)
1235{
1236  SHA512Update(ctx, indata, insize);
1237  return (ARCHIVE_OK);
1238}
1239
1240static int
1241__archive_libc2_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
1249static int
1250__archive_libc3_sha512init(archive_sha512_ctx *ctx)
1251{
1252  SHA512Init(ctx);
1253  return (ARCHIVE_OK);
1254}
1255
1256static int
1257__archive_libc3_sha512update(archive_sha512_ctx *ctx, const void *indata,
1258    size_t insize)
1259{
1260  SHA512Update(ctx, indata, insize);
1261  return (ARCHIVE_OK);
1262}
1263
1264static int
1265__archive_libc3_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
1273static int
1274__archive_libmd_sha512init(archive_sha512_ctx *ctx)
1275{
1276  SHA512_Init(ctx);
1277  return (ARCHIVE_OK);
1278}
1279
1280static int
1281__archive_libmd_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
1288static int
1289__archive_libmd_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
1297static int
1298__archive_libsystem_sha512init(archive_sha512_ctx *ctx)
1299{
1300  CC_SHA512_Init(ctx);
1301  return (ARCHIVE_OK);
1302}
1303
1304static int
1305__archive_libsystem_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
1312static int
1313__archive_libsystem_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
1321static int
1322__archive_mbedtls_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
1331static int
1332__archive_mbedtls_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
1341static int
1342__archive_mbedtls_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
1355static int
1356__archive_nettle_sha512init(archive_sha512_ctx *ctx)
1357{
1358  sha512_init(ctx);
1359  return (ARCHIVE_OK);
1360}
1361
1362static int
1363__archive_nettle_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
1370static int
1371__archive_nettle_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
1379static int
1380__archive_openssl_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
1388static int
1389__archive_openssl_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
1396static int
1397__archive_openssl_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
1409static int
1410__archive_windowsapi_sha512init(archive_sha512_ctx *ctx)
1411{
1412  return (win_crypto_init(ctx, CALG_SHA_512));
1413}
1414
1415static int
1416__archive_windowsapi_sha512update(archive_sha512_ctx *ctx, const void *indata,
1417    size_t insize)
1418{
1419  return (win_crypto_Update(ctx, indata, insize));
1420}
1421
1422static int
1423__archive_windowsapi_sha512final(archive_sha512_ctx *ctx, void *md)
1424{
1425  return (win_crypto_Final(md, 64, ctx));
1426}
1427
1428#else
1429
1430static int
1431__archive_stub_sha512init(archive_sha512_ctx *ctx)
1432{
1433	(void)ctx; /* UNUSED */
1434	return (ARCHIVE_FAILED);
1435}
1436
1437static int
1438__archive_stub_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
1447static int
1448__archive_stub_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 */
1468const struct archive_digest __archive_digest =
1469{
1470/* MD5 */
1471#if defined(ARCHIVE_CRYPTO_MD5_LIBC)
1472  &__archive_libc_md5init,
1473  &__archive_libc_md5update,
1474  &__archive_libc_md5final,
1475#elif defined(ARCHIVE_CRYPTO_MD5_LIBMD)
1476  &__archive_libmd_md5init,
1477  &__archive_libmd_md5update,
1478  &__archive_libmd_md5final,
1479#elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM)
1480  &__archive_libsystem_md5init,
1481  &__archive_libsystem_md5update,
1482  &__archive_libsystem_md5final,
1483#elif defined(ARCHIVE_CRYPTO_MD5_MBEDTLS)
1484  &__archive_mbedtls_md5init,
1485  &__archive_mbedtls_md5update,
1486  &__archive_mbedtls_md5final,
1487#elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
1488  &__archive_nettle_md5init,
1489  &__archive_nettle_md5update,
1490  &__archive_nettle_md5final,
1491#elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
1492  &__archive_openssl_md5init,
1493  &__archive_openssl_md5update,
1494  &__archive_openssl_md5final,
1495#elif defined(ARCHIVE_CRYPTO_MD5_WIN)
1496  &__archive_windowsapi_md5init,
1497  &__archive_windowsapi_md5update,
1498  &__archive_windowsapi_md5final,
1499#elif !defined(ARCHIVE_MD5_COMPILE_TEST)
1500  &__archive_stub_md5init,
1501  &__archive_stub_md5update,
1502  &__archive_stub_md5final,
1503#endif
1504
1505/* RIPEMD160 */
1506#if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
1507  &__archive_libc_ripemd160init,
1508  &__archive_libc_ripemd160update,
1509  &__archive_libc_ripemd160final,
1510#elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
1511  &__archive_libmd_ripemd160init,
1512  &__archive_libmd_ripemd160update,
1513  &__archive_libmd_ripemd160final,
1514#elif defined(ARCHIVE_CRYPTO_RMD160_MBEDTLS)
1515  &__archive_mbedtls_ripemd160init,
1516  &__archive_mbedtls_ripemd160update,
1517  &__archive_mbedtls_ripemd160final,
1518#elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
1519  &__archive_nettle_ripemd160init,
1520  &__archive_nettle_ripemd160update,
1521  &__archive_nettle_ripemd160final,
1522#elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
1523  &__archive_openssl_ripemd160init,
1524  &__archive_openssl_ripemd160update,
1525  &__archive_openssl_ripemd160final,
1526#elif !defined(ARCHIVE_RMD160_COMPILE_TEST)
1527  &__archive_stub_ripemd160init,
1528  &__archive_stub_ripemd160update,
1529  &__archive_stub_ripemd160final,
1530#endif
1531
1532/* SHA1 */
1533#if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
1534  &__archive_libc_sha1init,
1535  &__archive_libc_sha1update,
1536  &__archive_libc_sha1final,
1537#elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
1538  &__archive_libmd_sha1init,
1539  &__archive_libmd_sha1update,
1540  &__archive_libmd_sha1final,
1541#elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
1542  &__archive_libsystem_sha1init,
1543  &__archive_libsystem_sha1update,
1544  &__archive_libsystem_sha1final,
1545#elif defined(ARCHIVE_CRYPTO_SHA1_MBEDTLS)
1546  &__archive_mbedtls_sha1init,
1547  &__archive_mbedtls_sha1update,
1548  &__archive_mbedtls_sha1final,
1549#elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
1550  &__archive_nettle_sha1init,
1551  &__archive_nettle_sha1update,
1552  &__archive_nettle_sha1final,
1553#elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
1554  &__archive_openssl_sha1init,
1555  &__archive_openssl_sha1update,
1556  &__archive_openssl_sha1final,
1557#elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
1558  &__archive_windowsapi_sha1init,
1559  &__archive_windowsapi_sha1update,
1560  &__archive_windowsapi_sha1final,
1561#elif !defined(ARCHIVE_SHA1_COMPILE_TEST)
1562  &__archive_stub_sha1init,
1563  &__archive_stub_sha1update,
1564  &__archive_stub_sha1final,
1565#endif
1566
1567/* SHA256 */
1568#if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
1569  &__archive_libc_sha256init,
1570  &__archive_libc_sha256update,
1571  &__archive_libc_sha256final,
1572#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
1573  &__archive_libc2_sha256init,
1574  &__archive_libc2_sha256update,
1575  &__archive_libc2_sha256final,
1576#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
1577  &__archive_libc3_sha256init,
1578  &__archive_libc3_sha256update,
1579  &__archive_libc3_sha256final,
1580#elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
1581  &__archive_libmd_sha256init,
1582  &__archive_libmd_sha256update,
1583  &__archive_libmd_sha256final,
1584#elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
1585  &__archive_libsystem_sha256init,
1586  &__archive_libsystem_sha256update,
1587  &__archive_libsystem_sha256final,
1588#elif defined(ARCHIVE_CRYPTO_SHA256_MBEDTLS)
1589  &__archive_mbedtls_sha256init,
1590  &__archive_mbedtls_sha256update,
1591  &__archive_mbedtls_sha256final,
1592#elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
1593  &__archive_nettle_sha256init,
1594  &__archive_nettle_sha256update,
1595  &__archive_nettle_sha256final,
1596#elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
1597  &__archive_openssl_sha256init,
1598  &__archive_openssl_sha256update,
1599  &__archive_openssl_sha256final,
1600#elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
1601  &__archive_windowsapi_sha256init,
1602  &__archive_windowsapi_sha256update,
1603  &__archive_windowsapi_sha256final,
1604#elif !defined(ARCHIVE_SHA256_COMPILE_TEST)
1605  &__archive_stub_sha256init,
1606  &__archive_stub_sha256update,
1607  &__archive_stub_sha256final,
1608#endif
1609
1610/* SHA384 */
1611#if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
1612  &__archive_libc_sha384init,
1613  &__archive_libc_sha384update,
1614  &__archive_libc_sha384final,
1615#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
1616  &__archive_libc2_sha384init,
1617  &__archive_libc2_sha384update,
1618  &__archive_libc2_sha384final,
1619#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
1620  &__archive_libc3_sha384init,
1621  &__archive_libc3_sha384update,
1622  &__archive_libc3_sha384final,
1623#elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
1624  &__archive_libsystem_sha384init,
1625  &__archive_libsystem_sha384update,
1626  &__archive_libsystem_sha384final,
1627#elif defined(ARCHIVE_CRYPTO_SHA384_MBEDTLS)
1628  &__archive_mbedtls_sha384init,
1629  &__archive_mbedtls_sha384update,
1630  &__archive_mbedtls_sha384final,
1631#elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
1632  &__archive_nettle_sha384init,
1633  &__archive_nettle_sha384update,
1634  &__archive_nettle_sha384final,
1635#elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
1636  &__archive_openssl_sha384init,
1637  &__archive_openssl_sha384update,
1638  &__archive_openssl_sha384final,
1639#elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
1640  &__archive_windowsapi_sha384init,
1641  &__archive_windowsapi_sha384update,
1642  &__archive_windowsapi_sha384final,
1643#elif !defined(ARCHIVE_SHA384_COMPILE_TEST)
1644  &__archive_stub_sha384init,
1645  &__archive_stub_sha384update,
1646  &__archive_stub_sha384final,
1647#endif
1648
1649/* SHA512 */
1650#if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1651  &__archive_libc_sha512init,
1652  &__archive_libc_sha512update,
1653  &__archive_libc_sha512final
1654#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1655  &__archive_libc2_sha512init,
1656  &__archive_libc2_sha512update,
1657  &__archive_libc2_sha512final
1658#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1659  &__archive_libc3_sha512init,
1660  &__archive_libc3_sha512update,
1661  &__archive_libc3_sha512final
1662#elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1663  &__archive_libmd_sha512init,
1664  &__archive_libmd_sha512update,
1665  &__archive_libmd_sha512final
1666#elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1667  &__archive_libsystem_sha512init,
1668  &__archive_libsystem_sha512update,
1669  &__archive_libsystem_sha512final
1670#elif defined(ARCHIVE_CRYPTO_SHA512_MBEDTLS)
1671  &__archive_mbedtls_sha512init,
1672  &__archive_mbedtls_sha512update,
1673  &__archive_mbedtls_sha512final
1674#elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1675  &__archive_nettle_sha512init,
1676  &__archive_nettle_sha512update,
1677  &__archive_nettle_sha512final
1678#elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1679  &__archive_openssl_sha512init,
1680  &__archive_openssl_sha512update,
1681  &__archive_openssl_sha512final
1682#elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1683  &__archive_windowsapi_sha512init,
1684  &__archive_windowsapi_sha512update,
1685  &__archive_windowsapi_sha512final
1686#elif !defined(ARCHIVE_SHA512_COMPILE_TEST)
1687  &__archive_stub_sha512init,
1688  &__archive_stub_sha512update,
1689  &__archive_stub_sha512final
1690#endif
1691};
1692