CoCalc -- archive

GitHub Repository: Kitware/CMake
Path: blob/master/Utilities/cmlibarchive/libarchive/archive_digest.c
³¹⁵³ views
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
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
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
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
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
152
__archive_md5init(archive_md5_ctx *ctx)
153
{
154
  MD5Init(ctx);
155
  return (ARCHIVE_OK);
156
}
157

158
static int
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
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
176
__archive_md5init(archive_md5_ctx *ctx)
177
{
178
  MD5Init(ctx);
179
  return (ARCHIVE_OK);
180
}
181

182
static int
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
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
207
__archive_md5init(archive_md5_ctx *ctx)
208
{
209
  CC_MD5_Init(ctx);
210
  return (ARCHIVE_OK);
211
}
212

213
static int
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
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_MBEDTLS)
233

234
static int
235
__archive_md5init(archive_md5_ctx *ctx)
236
{
237
  mbedtls_md5_init(ctx);
238
  if (mbedtls_md5_starts_ret(ctx) == 0)
239
    return (ARCHIVE_OK);
240
  else
241
    return (ARCHIVE_FATAL);
242
}
243

244
static int
245
__archive_md5update(archive_md5_ctx *ctx, const void *indata,
246
    size_t insize)
247
{
248
  if (mbedtls_md5_update_ret(ctx, indata, insize) == 0)
249
    return (ARCHIVE_OK);
250
  else
251
    return (ARCHIVE_FATAL);
252
}
253

254
static int
255
__archive_md5final(archive_md5_ctx *ctx, void *md)
256
{
257
  if (mbedtls_md5_finish_ret(ctx, md) == 0) {
258
    mbedtls_md5_free(ctx);
259
    return (ARCHIVE_OK);
260
  } else {
261
    mbedtls_md5_free(ctx);
262
    return (ARCHIVE_FATAL);
263
  }
264
}
265

266
#elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
267

268
static int
269
__archive_md5init(archive_md5_ctx *ctx)
270
{
271
  md5_init(ctx);
272
  return (ARCHIVE_OK);
273
}
274

275
static int
276
__archive_md5update(archive_md5_ctx *ctx, const void *indata,
277
    size_t insize)
278
{
279
  md5_update(ctx, insize, indata);
280
  return (ARCHIVE_OK);
281
}
282

283
static int
284
__archive_md5final(archive_md5_ctx *ctx, void *md)
285
{
286
  md5_digest(ctx, MD5_DIGEST_SIZE, md);
287
  return (ARCHIVE_OK);
288
}
289

290
#elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
291

292
static int
293
__archive_md5init(archive_md5_ctx *ctx)
294
{
295
  if ((*ctx = EVP_MD_CTX_new()) == NULL)
296
	return (ARCHIVE_FAILED);
297
  if (!EVP_DigestInit(*ctx, EVP_md5()))
298
	return (ARCHIVE_FAILED);
299
  return (ARCHIVE_OK);
300
}
301

302
static int
303
__archive_md5update(archive_md5_ctx *ctx, const void *indata,
304
    size_t insize)
305
{
306
  EVP_DigestUpdate(*ctx, indata, insize);
307
  return (ARCHIVE_OK);
308
}
309

310
static int
311
__archive_md5final(archive_md5_ctx *ctx, void *md)
312
{
313
  /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
314
   * this is meant to cope with that. Real fix is probably to fix
315
   * archive_write_set_format_xar.c
316
   */
317
  if (*ctx) {
318
    EVP_DigestFinal(*ctx, md, NULL);
319
    EVP_MD_CTX_free(*ctx);
320
    *ctx = NULL;
321
  }
322
  return (ARCHIVE_OK);
323
}
324

325
#elif defined(ARCHIVE_CRYPTO_MD5_WIN)
326

327
static int
328
__archive_md5init(archive_md5_ctx *ctx)
329
{
330
#if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
331
  return (win_crypto_init(ctx, BCRYPT_MD5_ALGORITHM));
332
#else
333
  return (win_crypto_init(ctx, PROV_RSA_FULL, CALG_MD5));
334
#endif
335
}
336

337
static int
338
__archive_md5update(archive_md5_ctx *ctx, const void *indata,
339
    size_t insize)
340
{
341
  return (win_crypto_Update(ctx, indata, insize));
342
}
343

344
static int
345
__archive_md5final(archive_md5_ctx *ctx, void *md)
346
{
347
  return (win_crypto_Final(md, 16, ctx));
348
}
349

350
#else
351

352
static int
353
__archive_md5init(archive_md5_ctx *ctx)
354
{
355
	(void)ctx; /* UNUSED */
356
	return (ARCHIVE_FAILED);
357
}
358

359
static int
360
__archive_md5update(archive_md5_ctx *ctx, const void *indata,
361
    size_t insize)
362
{
363
	(void)ctx; /* UNUSED */
364
	(void)indata; /* UNUSED */
365
	(void)insize; /* UNUSED */
366
	return (ARCHIVE_FAILED);
367
}
368

369
static int
370
__archive_md5final(archive_md5_ctx *ctx, void *md)
371
{
372
	(void)ctx; /* UNUSED */
373
	(void)md; /* UNUSED */
374
	return (ARCHIVE_FAILED);
375
}
376

377
#endif
378

379
/* RIPEMD160 implementations */
380
#if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
381

382
static int
383
__archive_ripemd160init(archive_rmd160_ctx *ctx)
384
{
385
  RMD160Init(ctx);
386
  return (ARCHIVE_OK);
387
}
388

389
static int
390
__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
391
    size_t insize)
392
{
393
  RMD160Update(ctx, indata, insize);
394
  return (ARCHIVE_OK);
395
}
396

397
static int
398
__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
399
{
400
  RMD160Final(md, ctx);
401
  return (ARCHIVE_OK);
402
}
403

404
#elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
405

406
static int
407
__archive_ripemd160init(archive_rmd160_ctx *ctx)
408
{
409
  RIPEMD160_Init(ctx);
410
  return (ARCHIVE_OK);
411
}
412

413
static int
414
__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
415
    size_t insize)
416
{
417
  RIPEMD160_Update(ctx, indata, insize);
418
  return (ARCHIVE_OK);
419
}
420

421
static int
422
__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
423
{
424
  RIPEMD160_Final(md, ctx);
425
  return (ARCHIVE_OK);
426
}
427

428
#elif defined(ARCHIVE_CRYPTO_RMD160_MBEDTLS)
429

430
static int
431
__archive_ripemd160init(archive_rmd160_ctx *ctx)
432
{
433
  mbedtls_ripemd160_init(ctx);
434
  if (mbedtls_ripemd160_starts_ret(ctx) == 0)
435
    return (ARCHIVE_OK);
436
  else
437
    return (ARCHIVE_FATAL);
438
}
439

440
static int
441
__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
442
    size_t insize)
443
{
444
  if (mbedtls_ripemd160_update_ret(ctx, indata, insize) == 0)
445
    return (ARCHIVE_OK);
446
  else
447
    return (ARCHIVE_FATAL);
448
}
449

450
static int
451
__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
452
{
453
  if (mbedtls_ripemd160_finish_ret(ctx, md) == 0) {
454
    mbedtls_ripemd160_free(ctx);
455
    return (ARCHIVE_OK);
456
  } else {
457
    mbedtls_ripemd160_free(ctx);
458
    return (ARCHIVE_FATAL);
459
  }
460
}
461

462
#elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
463

464
static int
465
__archive_ripemd160init(archive_rmd160_ctx *ctx)
466
{
467
  ripemd160_init(ctx);
468
  return (ARCHIVE_OK);
469
}
470

471
static int
472
__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
473
    size_t insize)
474
{
475
  ripemd160_update(ctx, insize, indata);
476
  return (ARCHIVE_OK);
477
}
478

479
static int
480
__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
481
{
482
  ripemd160_digest(ctx, RIPEMD160_DIGEST_SIZE, md);
483
  return (ARCHIVE_OK);
484
}
485

486
#elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
487

488
static int
489
__archive_ripemd160init(archive_rmd160_ctx *ctx)
490
{
491
  if ((*ctx = EVP_MD_CTX_new()) == NULL)
492
	return (ARCHIVE_FAILED);
493
  if (!EVP_DigestInit(*ctx, EVP_ripemd160()))
494
	return (ARCHIVE_FAILED);
495
  return (ARCHIVE_OK);
496
}
497

498
static int
499
__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
500
    size_t insize)
501
{
502
  EVP_DigestUpdate(*ctx, indata, insize);
503
  return (ARCHIVE_OK);
504
}
505

506
static int
507
__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
508
{
509
  if (*ctx) {
510
    EVP_DigestFinal(*ctx, md, NULL);
511
    EVP_MD_CTX_free(*ctx);
512
    *ctx = NULL;
513
  }
514
  return (ARCHIVE_OK);
515
}
516

517
#else
518

519
static int
520
__archive_ripemd160init(archive_rmd160_ctx *ctx)
521
{
522
	(void)ctx; /* UNUSED */
523
	return (ARCHIVE_FAILED);
524
}
525

526
static int
527
__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
528
    size_t insize)
529
{
530
	(void)ctx; /* UNUSED */
531
	(void)indata; /* UNUSED */
532
	(void)insize; /* UNUSED */
533
	return (ARCHIVE_FAILED);
534
}
535

536
static int
537
__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
538
{
539
	(void)ctx; /* UNUSED */
540
	(void)md; /* UNUSED */
541
	return (ARCHIVE_FAILED);
542
}
543

544
#endif
545

546
/* SHA1 implementations */
547
#if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
548

549
static int
550
__archive_sha1init(archive_sha1_ctx *ctx)
551
{
552
  SHA1Init(ctx);
553
  return (ARCHIVE_OK);
554
}
555

556
static int
557
__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
558
    size_t insize)
559
{
560
  SHA1Update(ctx, indata, insize);
561
  return (ARCHIVE_OK);
562
}
563

564
static int
565
__archive_sha1final(archive_sha1_ctx *ctx, void *md)
566
{
567
  SHA1Final(md, ctx);
568
  return (ARCHIVE_OK);
569
}
570

571
#elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
572

573
static int
574
__archive_sha1init(archive_sha1_ctx *ctx)
575
{
576
  SHA1_Init(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
  SHA1_Update(ctx, indata, insize);
585
  return (ARCHIVE_OK);
586
}
587

588
static int
589
__archive_sha1final(archive_sha1_ctx *ctx, void *md)
590
{
591
  SHA1_Final(md, ctx);
592
  return (ARCHIVE_OK);
593
}
594

595
#elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
596

597
static int
598
__archive_sha1init(archive_sha1_ctx *ctx)
599
{
600
  CC_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
  CC_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
  CC_SHA1_Final(md, ctx);
616
  return (ARCHIVE_OK);
617
}
618

619
#elif defined(ARCHIVE_CRYPTO_SHA1_MBEDTLS)
620

621
static int
622
__archive_sha1init(archive_sha1_ctx *ctx)
623
{
624
  mbedtls_sha1_init(ctx);
625
  if (mbedtls_sha1_starts_ret(ctx) == 0)
626
    return (ARCHIVE_OK);
627
  else
628
    return (ARCHIVE_FATAL);
629
}
630

631
static int
632
__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
633
    size_t insize)
634
{
635
  if (mbedtls_sha1_update_ret(ctx, indata, insize) == 0)
636
    return (ARCHIVE_OK);
637
  else
638
    return (ARCHIVE_FATAL);
639
}
640

641
static int
642
__archive_sha1final(archive_sha1_ctx *ctx, void *md)
643
{
644
  if (mbedtls_sha1_finish_ret(ctx, md) == 0) {
645
    mbedtls_sha1_free(ctx);
646
    return (ARCHIVE_OK);
647
  } else {
648
    mbedtls_sha1_free(ctx);
649
    return (ARCHIVE_FATAL);
650
  }
651
}
652

653
#elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
654

655
static int
656
__archive_sha1init(archive_sha1_ctx *ctx)
657
{
658
  sha1_init(ctx);
659
  return (ARCHIVE_OK);
660
}
661

662
static int
663
__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
664
    size_t insize)
665
{
666
  sha1_update(ctx, insize, indata);
667
  return (ARCHIVE_OK);
668
}
669

670
static int
671
__archive_sha1final(archive_sha1_ctx *ctx, void *md)
672
{
673
  sha1_digest(ctx, SHA1_DIGEST_SIZE, md);
674
  return (ARCHIVE_OK);
675
}
676

677
#elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
678

679
static int
680
__archive_sha1init(archive_sha1_ctx *ctx)
681
{
682
  if ((*ctx = EVP_MD_CTX_new()) == NULL)
683
	return (ARCHIVE_FAILED);
684
  if (!EVP_DigestInit(*ctx, EVP_sha1()))
685
	return (ARCHIVE_FAILED);
686
  return (ARCHIVE_OK);
687
}
688

689
static int
690
__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
691
    size_t insize)
692
{
693
  EVP_DigestUpdate(*ctx, indata, insize);
694
  return (ARCHIVE_OK);
695
}
696

697
static int
698
__archive_sha1final(archive_sha1_ctx *ctx, void *md)
699
{
700
  /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
701
   * this is meant to cope with that. Real fix is probably to fix
702
   * archive_write_set_format_xar.c
703
   */
704
  if (*ctx) {
705
    EVP_DigestFinal(*ctx, md, NULL);
706
    EVP_MD_CTX_free(*ctx);
707
    *ctx = NULL;
708
  }
709
  return (ARCHIVE_OK);
710
}
711

712
#elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
713

714
static int
715
__archive_sha1init(archive_sha1_ctx *ctx)
716
{
717
#if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
718
  return (win_crypto_init(ctx, BCRYPT_SHA1_ALGORITHM));
719
#else
720
  return (win_crypto_init(ctx, PROV_RSA_FULL, CALG_SHA1));
721
#endif
722
}
723

724
static int
725
__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
726
    size_t insize)
727
{
728
  return (win_crypto_Update(ctx, indata, insize));
729
}
730

731
static int
732
__archive_sha1final(archive_sha1_ctx *ctx, void *md)
733
{
734
  return (win_crypto_Final(md, 20, ctx));
735
}
736

737
#else
738

739
static int
740
__archive_sha1init(archive_sha1_ctx *ctx)
741
{
742
	(void)ctx; /* UNUSED */
743
	return (ARCHIVE_FAILED);
744
}
745

746
static int
747
__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
748
    size_t insize)
749
{
750
	(void)ctx; /* UNUSED */
751
	(void)indata; /* UNUSED */
752
	(void)insize; /* UNUSED */
753
	return (ARCHIVE_FAILED);
754
}
755

756
static int
757
__archive_sha1final(archive_sha1_ctx *ctx, void *md)
758
{
759
	(void)ctx; /* UNUSED */
760
	(void)md; /* UNUSED */
761
	return (ARCHIVE_FAILED);
762
}
763

764
#endif
765

766
/* SHA256 implementations */
767
#if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
768

769
static int
770
__archive_sha256init(archive_sha256_ctx *ctx)
771
{
772
  SHA256_Init(ctx);
773
  return (ARCHIVE_OK);
774
}
775

776
static int
777
__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
778
    size_t insize)
779
{
780
  SHA256_Update(ctx, indata, insize);
781
  return (ARCHIVE_OK);
782
}
783

784
static int
785
__archive_sha256final(archive_sha256_ctx *ctx, void *md)
786
{
787
  SHA256_Final(md, ctx);
788
  return (ARCHIVE_OK);
789
}
790

791
#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
792

793
static int
794
__archive_sha256init(archive_sha256_ctx *ctx)
795
{
796
  SHA256Init(ctx);
797
  return (ARCHIVE_OK);
798
}
799

800
static int
801
__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
802
    size_t insize)
803
{
804
  SHA256Update(ctx, indata, insize);
805
  return (ARCHIVE_OK);
806
}
807

808
static int
809
__archive_sha256final(archive_sha256_ctx *ctx, void *md)
810
{
811
  SHA256Final(md, ctx);
812
  return (ARCHIVE_OK);
813
}
814

815
#elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
816

817
static int
818
__archive_sha256init(archive_sha256_ctx *ctx)
819
{
820
  SHA256Init(ctx);
821
  return (ARCHIVE_OK);
822
}
823

824
static int
825
__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
826
    size_t insize)
827
{
828
  SHA256Update(ctx, indata, insize);
829
  return (ARCHIVE_OK);
830
}
831

832
static int
833
__archive_sha256final(archive_sha256_ctx *ctx, void *md)
834
{
835
  SHA256Final(md, ctx);
836
  return (ARCHIVE_OK);
837
}
838

839
#elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
840

841
static int
842
__archive_sha256init(archive_sha256_ctx *ctx)
843
{
844
  SHA256_Init(ctx);
845
  return (ARCHIVE_OK);
846
}
847

848
static int
849
__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
850
    size_t insize)
851
{
852
  SHA256_Update(ctx, indata, insize);
853
  return (ARCHIVE_OK);
854
}
855

856
static int
857
__archive_sha256final(archive_sha256_ctx *ctx, void *md)
858
{
859
  SHA256_Final(md, ctx);
860
  return (ARCHIVE_OK);
861
}
862

863
#elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
864

865
static int
866
__archive_sha256init(archive_sha256_ctx *ctx)
867
{
868
  CC_SHA256_Init(ctx);
869
  return (ARCHIVE_OK);
870
}
871

872
static int
873
__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
874
    size_t insize)
875
{
876
  CC_SHA256_Update(ctx, indata, insize);
877
  return (ARCHIVE_OK);
878
}
879

880
static int
881
__archive_sha256final(archive_sha256_ctx *ctx, void *md)
882
{
883
  CC_SHA256_Final(md, ctx);
884
  return (ARCHIVE_OK);
885
}
886

887
#elif defined(ARCHIVE_CRYPTO_SHA256_MBEDTLS)
888

889
static int
890
__archive_sha256init(archive_sha256_ctx *ctx)
891
{
892
  mbedtls_sha256_init(ctx);
893
  if (mbedtls_sha256_starts_ret(ctx, 0) == 0)
894
    return (ARCHIVE_OK);
895
  else
896
    return (ARCHIVE_FATAL);
897
}
898

899
static int
900
__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
901
    size_t insize)
902
{
903
  if (mbedtls_sha256_update_ret(ctx, indata, insize) == 0)
904
    return (ARCHIVE_OK);
905
  else
906
    return (ARCHIVE_FATAL);
907
}
908

909
static int
910
__archive_sha256final(archive_sha256_ctx *ctx, void *md)
911
{
912
  if (mbedtls_sha256_finish_ret(ctx, md) == 0) {
913
    mbedtls_sha256_free(ctx);
914
    return (ARCHIVE_OK);
915
  } else {
916
    mbedtls_sha256_free(ctx);
917
    return (ARCHIVE_FATAL);
918
  }
919
}
920

921
#elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
922

923
static int
924
__archive_sha256init(archive_sha256_ctx *ctx)
925
{
926
  sha256_init(ctx);
927
  return (ARCHIVE_OK);
928
}
929

930
static int
931
__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
932
    size_t insize)
933
{
934
  sha256_update(ctx, insize, indata);
935
  return (ARCHIVE_OK);
936
}
937

938
static int
939
__archive_sha256final(archive_sha256_ctx *ctx, void *md)
940
{
941
  sha256_digest(ctx, SHA256_DIGEST_SIZE, md);
942
  return (ARCHIVE_OK);
943
}
944

945
#elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
946

947
static int
948
__archive_sha256init(archive_sha256_ctx *ctx)
949
{
950
  if ((*ctx = EVP_MD_CTX_new()) == NULL)
951
	return (ARCHIVE_FAILED);
952
  if (!EVP_DigestInit(*ctx, EVP_sha256()))
953
	return (ARCHIVE_FAILED);
954
  return (ARCHIVE_OK);
955
}
956

957
static int
958
__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
959
    size_t insize)
960
{
961
  EVP_DigestUpdate(*ctx, indata, insize);
962
  return (ARCHIVE_OK);
963
}
964

965
static int
966
__archive_sha256final(archive_sha256_ctx *ctx, void *md)
967
{
968
  if (*ctx) {
969
    EVP_DigestFinal(*ctx, md, NULL);
970
    EVP_MD_CTX_free(*ctx);
971
    *ctx = NULL;
972
  }
973
  return (ARCHIVE_OK);
974
}
975

976
#elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
977

978
static int
979
__archive_sha256init(archive_sha256_ctx *ctx)
980
{
981
#if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
982
  return (win_crypto_init(ctx, BCRYPT_SHA256_ALGORITHM));
983
#else
984
  return (win_crypto_init(ctx, PROV_RSA_AES, CALG_SHA_256));
985
#endif
986
}
987

988
static int
989
__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
990
    size_t insize)
991
{
992
  return (win_crypto_Update(ctx, indata, insize));
993
}
994

995
static int
996
__archive_sha256final(archive_sha256_ctx *ctx, void *md)
997
{
998
  return (win_crypto_Final(md, 32, ctx));
999
}
1000

1001
#else
1002

1003
static int
1004
__archive_sha256init(archive_sha256_ctx *ctx)
1005
{
1006
	(void)ctx; /* UNUSED */
1007
	return (ARCHIVE_FAILED);
1008
}
1009

1010
static int
1011
__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
1012
    size_t insize)
1013
{
1014
	(void)ctx; /* UNUSED */
1015
	(void)indata; /* UNUSED */
1016
	(void)insize; /* UNUSED */
1017
	return (ARCHIVE_FAILED);
1018
}
1019

1020
static int
1021
__archive_sha256final(archive_sha256_ctx *ctx, void *md)
1022
{
1023
	(void)ctx; /* UNUSED */
1024
	(void)md; /* UNUSED */
1025
	return (ARCHIVE_FAILED);
1026
}
1027

1028
#endif
1029

1030
/* SHA384 implementations */
1031
#if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
1032

1033
static int
1034
__archive_sha384init(archive_sha384_ctx *ctx)
1035
{
1036
  SHA384_Init(ctx);
1037
  return (ARCHIVE_OK);
1038
}
1039

1040
static int
1041
__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1042
    size_t insize)
1043
{
1044
  SHA384_Update(ctx, indata, insize);
1045
  return (ARCHIVE_OK);
1046
}
1047

1048
static int
1049
__archive_sha384final(archive_sha384_ctx *ctx, void *md)
1050
{
1051
  SHA384_Final(md, ctx);
1052
  return (ARCHIVE_OK);
1053
}
1054

1055
#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
1056

1057
static int
1058
__archive_sha384init(archive_sha384_ctx *ctx)
1059
{
1060
  SHA384Init(ctx);
1061
  return (ARCHIVE_OK);
1062
}
1063

1064
static int
1065
__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1066
    size_t insize)
1067
{
1068
  SHA384Update(ctx, indata, insize);
1069
  return (ARCHIVE_OK);
1070
}
1071

1072
static int
1073
__archive_sha384final(archive_sha384_ctx *ctx, void *md)
1074
{
1075
  SHA384Final(md, ctx);
1076
  return (ARCHIVE_OK);
1077
}
1078

1079
#elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
1080

1081
static int
1082
__archive_sha384init(archive_sha384_ctx *ctx)
1083
{
1084
  SHA384Init(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
  SHA384Update(ctx, indata, insize);
1093
  return (ARCHIVE_OK);
1094
}
1095

1096
static int
1097
__archive_sha384final(archive_sha384_ctx *ctx, void *md)
1098
{
1099
  SHA384Final(md, ctx);
1100
  return (ARCHIVE_OK);
1101
}
1102

1103
#elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
1104

1105
static int
1106
__archive_sha384init(archive_sha384_ctx *ctx)
1107
{
1108
  CC_SHA384_Init(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
  CC_SHA384_Update(ctx, indata, insize);
1117
  return (ARCHIVE_OK);
1118
}
1119

1120
static int
1121
__archive_sha384final(archive_sha384_ctx *ctx, void *md)
1122
{
1123
  CC_SHA384_Final(md, ctx);
1124
  return (ARCHIVE_OK);
1125
}
1126

1127
#elif defined(ARCHIVE_CRYPTO_SHA384_MBEDTLS)
1128

1129
static int
1130
__archive_sha384init(archive_sha384_ctx *ctx)
1131
{
1132
  mbedtls_sha512_init(ctx);
1133
  if (mbedtls_sha512_starts_ret(ctx, 1) == 0)
1134
    return (ARCHIVE_OK);
1135
  else
1136
    return (ARCHIVE_FATAL);
1137
}
1138

1139
static int
1140
__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1141
    size_t insize)
1142
{
1143
  if (mbedtls_sha512_update_ret(ctx, indata, insize) == 0)
1144
    return (ARCHIVE_OK);
1145
  else
1146
    return (ARCHIVE_FATAL);
1147
}
1148

1149
static int
1150
__archive_sha384final(archive_sha384_ctx *ctx, void *md)
1151
{
1152
  if (mbedtls_sha512_finish_ret(ctx, md) == 0) {
1153
    mbedtls_sha512_free(ctx);
1154
    return (ARCHIVE_OK);
1155
  } else {
1156
    mbedtls_sha512_free(ctx);
1157
    return (ARCHIVE_FATAL);
1158
  }
1159
}
1160

1161
#elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
1162

1163
static int
1164
__archive_sha384init(archive_sha384_ctx *ctx)
1165
{
1166
  sha384_init(ctx);
1167
  return (ARCHIVE_OK);
1168
}
1169

1170
static int
1171
__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1172
    size_t insize)
1173
{
1174
  sha384_update(ctx, insize, indata);
1175
  return (ARCHIVE_OK);
1176
}
1177

1178
static int
1179
__archive_sha384final(archive_sha384_ctx *ctx, void *md)
1180
{
1181
  sha384_digest(ctx, SHA384_DIGEST_SIZE, md);
1182
  return (ARCHIVE_OK);
1183
}
1184

1185
#elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
1186

1187
static int
1188
__archive_sha384init(archive_sha384_ctx *ctx)
1189
{
1190
  if ((*ctx = EVP_MD_CTX_new()) == NULL)
1191
	return (ARCHIVE_FAILED);
1192
  if (!EVP_DigestInit(*ctx, EVP_sha384()))
1193
	return (ARCHIVE_FAILED);
1194
  return (ARCHIVE_OK);
1195
}
1196

1197
static int
1198
__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1199
    size_t insize)
1200
{
1201
  EVP_DigestUpdate(*ctx, indata, insize);
1202
  return (ARCHIVE_OK);
1203
}
1204

1205
static int
1206
__archive_sha384final(archive_sha384_ctx *ctx, void *md)
1207
{
1208
  if (*ctx) {
1209
    EVP_DigestFinal(*ctx, md, NULL);
1210
    EVP_MD_CTX_free(*ctx);
1211
    *ctx = NULL;
1212
  }
1213
  return (ARCHIVE_OK);
1214
}
1215

1216
#elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
1217

1218
static int
1219
__archive_sha384init(archive_sha384_ctx *ctx)
1220
{
1221
#if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
1222
  return (win_crypto_init(ctx, BCRYPT_SHA384_ALGORITHM));
1223
#else
1224
  return (win_crypto_init(ctx, PROV_RSA_AES, CALG_SHA_384));
1225
#endif
1226
}
1227

1228
static int
1229
__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1230
    size_t insize)
1231
{
1232
  return (win_crypto_Update(ctx, indata, insize));
1233
}
1234

1235
static int
1236
__archive_sha384final(archive_sha384_ctx *ctx, void *md)
1237
{
1238
  return (win_crypto_Final(md, 48, ctx));
1239
}
1240

1241
#else
1242

1243
static int
1244
__archive_sha384init(archive_sha384_ctx *ctx)
1245
{
1246
	(void)ctx; /* UNUSED */
1247
	return (ARCHIVE_FAILED);
1248
}
1249

1250
static int
1251
__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
1252
    size_t insize)
1253
{
1254
	(void)ctx; /* UNUSED */
1255
	(void)indata; /* UNUSED */
1256
	(void)insize; /* UNUSED */
1257
	return (ARCHIVE_FAILED);
1258
}
1259

1260
static int
1261
__archive_sha384final(archive_sha384_ctx *ctx, void *md)
1262
{
1263
	(void)ctx; /* UNUSED */
1264
	(void)md; /* UNUSED */
1265
	return (ARCHIVE_FAILED);
1266
}
1267

1268
#endif
1269

1270
/* SHA512 implementations */
1271
#if defined(ARCHIVE_CRYPTO_SHA512_LIBC)
1272

1273
static int
1274
__archive_sha512init(archive_sha512_ctx *ctx)
1275
{
1276
  SHA512_Init(ctx);
1277
  return (ARCHIVE_OK);
1278
}
1279

1280
static int
1281
__archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1282
    size_t insize)
1283
{
1284
  SHA512_Update(ctx, indata, insize);
1285
  return (ARCHIVE_OK);
1286
}
1287

1288
static int
1289
__archive_sha512final(archive_sha512_ctx *ctx, void *md)
1290
{
1291
  SHA512_Final(md, ctx);
1292
  return (ARCHIVE_OK);
1293
}
1294

1295
#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC2)
1296

1297
static int
1298
__archive_sha512init(archive_sha512_ctx *ctx)
1299
{
1300
  SHA512Init(ctx);
1301
  return (ARCHIVE_OK);
1302
}
1303

1304
static int
1305
__archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1306
    size_t insize)
1307
{
1308
  SHA512Update(ctx, indata, insize);
1309
  return (ARCHIVE_OK);
1310
}
1311

1312
static int
1313
__archive_sha512final(archive_sha512_ctx *ctx, void *md)
1314
{
1315
  SHA512Final(md, ctx);
1316
  return (ARCHIVE_OK);
1317
}
1318

1319
#elif defined(ARCHIVE_CRYPTO_SHA512_LIBC3)
1320

1321
static int
1322
__archive_sha512init(archive_sha512_ctx *ctx)
1323
{
1324
  SHA512Init(ctx);
1325
  return (ARCHIVE_OK);
1326
}
1327

1328
static int
1329
__archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1330
    size_t insize)
1331
{
1332
  SHA512Update(ctx, indata, insize);
1333
  return (ARCHIVE_OK);
1334
}
1335

1336
static int
1337
__archive_sha512final(archive_sha512_ctx *ctx, void *md)
1338
{
1339
  SHA512Final(md, ctx);
1340
  return (ARCHIVE_OK);
1341
}
1342

1343
#elif defined(ARCHIVE_CRYPTO_SHA512_LIBMD)
1344

1345
static int
1346
__archive_sha512init(archive_sha512_ctx *ctx)
1347
{
1348
  SHA512_Init(ctx);
1349
  return (ARCHIVE_OK);
1350
}
1351

1352
static int
1353
__archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1354
    size_t insize)
1355
{
1356
  SHA512_Update(ctx, indata, insize);
1357
  return (ARCHIVE_OK);
1358
}
1359

1360
static int
1361
__archive_sha512final(archive_sha512_ctx *ctx, void *md)
1362
{
1363
  SHA512_Final(md, ctx);
1364
  return (ARCHIVE_OK);
1365
}
1366

1367
#elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
1368

1369
static int
1370
__archive_sha512init(archive_sha512_ctx *ctx)
1371
{
1372
  CC_SHA512_Init(ctx);
1373
  return (ARCHIVE_OK);
1374
}
1375

1376
static int
1377
__archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1378
    size_t insize)
1379
{
1380
  CC_SHA512_Update(ctx, indata, insize);
1381
  return (ARCHIVE_OK);
1382
}
1383

1384
static int
1385
__archive_sha512final(archive_sha512_ctx *ctx, void *md)
1386
{
1387
  CC_SHA512_Final(md, ctx);
1388
  return (ARCHIVE_OK);
1389
}
1390

1391
#elif defined(ARCHIVE_CRYPTO_SHA512_MBEDTLS)
1392

1393
static int
1394
__archive_sha512init(archive_sha512_ctx *ctx)
1395
{
1396
  mbedtls_sha512_init(ctx);
1397
  if (mbedtls_sha512_starts_ret(ctx, 0) == 0)
1398
    return (ARCHIVE_OK);
1399
  else
1400
    return (ARCHIVE_FATAL);
1401
}
1402

1403
static int
1404
__archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1405
    size_t insize)
1406
{
1407
  if (mbedtls_sha512_update_ret(ctx, indata, insize) == 0)
1408
    return (ARCHIVE_OK);
1409
  else
1410
    return (ARCHIVE_FATAL);
1411
}
1412

1413
static int
1414
__archive_sha512final(archive_sha512_ctx *ctx, void *md)
1415
{
1416
  if (mbedtls_sha512_finish_ret(ctx, md) == 0) {
1417
    mbedtls_sha512_free(ctx);
1418
    return (ARCHIVE_OK);
1419
  } else {
1420
    mbedtls_sha512_free(ctx);
1421
    return (ARCHIVE_FATAL);
1422
  }
1423
}
1424

1425
#elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
1426

1427
static int
1428
__archive_sha512init(archive_sha512_ctx *ctx)
1429
{
1430
  sha512_init(ctx);
1431
  return (ARCHIVE_OK);
1432
}
1433

1434
static int
1435
__archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1436
    size_t insize)
1437
{
1438
  sha512_update(ctx, insize, indata);
1439
  return (ARCHIVE_OK);
1440
}
1441

1442
static int
1443
__archive_sha512final(archive_sha512_ctx *ctx, void *md)
1444
{
1445
  sha512_digest(ctx, SHA512_DIGEST_SIZE, md);
1446
  return (ARCHIVE_OK);
1447
}
1448

1449
#elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
1450

1451
static int
1452
__archive_sha512init(archive_sha512_ctx *ctx)
1453
{
1454
  if ((*ctx = EVP_MD_CTX_new()) == NULL)
1455
	return (ARCHIVE_FAILED);
1456
  if (!EVP_DigestInit(*ctx, EVP_sha512()))
1457
	return (ARCHIVE_FAILED);
1458
  return (ARCHIVE_OK);
1459
}
1460

1461
static int
1462
__archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1463
    size_t insize)
1464
{
1465
  EVP_DigestUpdate(*ctx, indata, insize);
1466
  return (ARCHIVE_OK);
1467
}
1468

1469
static int
1470
__archive_sha512final(archive_sha512_ctx *ctx, void *md)
1471
{
1472
  if (*ctx) {
1473
    EVP_DigestFinal(*ctx, md, NULL);
1474
    EVP_MD_CTX_free(*ctx);
1475
    *ctx = NULL;
1476
  }
1477
  return (ARCHIVE_OK);
1478
}
1479

1480
#elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
1481

1482
static int
1483
__archive_sha512init(archive_sha512_ctx *ctx)
1484
{
1485
#if defined(HAVE_BCRYPT_H) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
1486
  return (win_crypto_init(ctx, BCRYPT_SHA512_ALGORITHM));
1487
#else
1488
  return (win_crypto_init(ctx, PROV_RSA_AES, CALG_SHA_512));
1489
#endif
1490
}
1491

1492
static int
1493
__archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1494
    size_t insize)
1495
{
1496
  return (win_crypto_Update(ctx, indata, insize));
1497
}
1498

1499
static int
1500
__archive_sha512final(archive_sha512_ctx *ctx, void *md)
1501
{
1502
  return (win_crypto_Final(md, 64, ctx));
1503
}
1504

1505
#else
1506

1507
static int
1508
__archive_sha512init(archive_sha512_ctx *ctx)
1509
{
1510
	(void)ctx; /* UNUSED */
1511
	return (ARCHIVE_FAILED);
1512
}
1513

1514
static int
1515
__archive_sha512update(archive_sha512_ctx *ctx, const void *indata,
1516
    size_t insize)
1517
{
1518
	(void)ctx; /* UNUSED */
1519
	(void)indata; /* UNUSED */
1520
	(void)insize; /* UNUSED */
1521
	return (ARCHIVE_FAILED);
1522
}
1523

1524
static int
1525
__archive_sha512final(archive_sha512_ctx *ctx, void *md)
1526
{
1527
	(void)ctx; /* UNUSED */
1528
	(void)md; /* UNUSED */
1529
	return (ARCHIVE_FAILED);
1530
}
1531

1532
#endif
1533

1534
/* NOTE: Message Digest functions are set based on availability and by the
1535
 * following order of preference.
1536
 * 1. libc
1537
 * 2. libc2
1538
 * 3. libc3
1539
 * 4. libSystem
1540
 * 5. Nettle
1541
 * 6. OpenSSL
1542
 * 7. libmd
1543
 * 8. Windows API
1544
 */
1545
const struct archive_digest __archive_digest =
1546
{
1547
/* MD5 */
1548
  &__archive_md5init,
1549
  &__archive_md5update,
1550
  &__archive_md5final,
1551

1552
/* RIPEMD160 */
1553
  &__archive_ripemd160init,
1554
  &__archive_ripemd160update,
1555
  &__archive_ripemd160final,
1556

1557
/* SHA1 */
1558
  &__archive_sha1init,
1559
  &__archive_sha1update,
1560
  &__archive_sha1final,
1561

1562
/* SHA256 */
1563
  &__archive_sha256init,
1564
  &__archive_sha256update,
1565
  &__archive_sha256final,
1566

1567
/* SHA384 */
1568
  &__archive_sha384init,
1569
  &__archive_sha384update,
1570
  &__archive_sha384final,
1571

1572
/* SHA512 */
1573
  &__archive_sha512init,
1574
  &__archive_sha512update,
1575
  &__archive_sha512final
1576
};
1577

1578
Product

Resources

Company
