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