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