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