VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/crypto/digest-builtin.cpp@ 96763

Last change on this file since 96763 was 96407, checked in by vboxsync, 2 years ago

scm copyright and license note update
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 29.9 KB
Line 
1/* $Id: digest-builtin.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2/** @file
3 * IPRT - Crypto - Cryptographic Hash / Message Digest API, Built-in providers.
4 */
5
6/*
7 * Copyright (C) 2006-2022 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * The contents of this file may alternatively be used under the terms
26 * of the Common Development and Distribution License Version 1.0
27 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28 * in the VirtualBox distribution, in which case the provisions of the
29 * CDDL are applicable instead of those of the GPL.
30 *
31 * You may elect to license modified versions of this file under the
32 * terms and conditions of either the GPL or the CDDL or both.
33 *
34 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35 */
36
37
38/*********************************************************************************************************************************
39* Header Files *
40*********************************************************************************************************************************/
41#include "internal/iprt.h"
42#include <iprt/crypto/digest.h>
43
44#include <iprt/err.h>
45#include <iprt/mem.h>
46#include <iprt/string.h>
47#include <iprt/md2.h>
48#include <iprt/md4.h>
49#include <iprt/md5.h>
50#include <iprt/sha.h>
51#include <iprt/crypto/pkix.h>
52
53#ifdef IPRT_WITH_OPENSSL
54# include "internal/iprt-openssl.h"
55# include "internal/openssl-pre.h"
56# include <openssl/evp.h>
57# include "internal/openssl-post.h"
58#endif
59
60
61
62/*
63 * MD2
64 */
65#ifndef IPRT_WITHOUT_DIGEST_MD2
66
67/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
68static DECLCALLBACK(void) rtCrDigestMd2_Update(void *pvState, const void *pvData, size_t cbData)
69{
70 RTMd2Update((PRTMD2CONTEXT)pvState, pvData, cbData);
71}
72
73/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
74static DECLCALLBACK(void) rtCrDigestMd2_Final(void *pvState, uint8_t *pbHash)
75{
76 RTMd2Final((PRTMD2CONTEXT)pvState, pbHash);
77}
78
79/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
80static DECLCALLBACK(int) rtCrDigestMd2_Init(void *pvState, void *pvOpaque, bool fReInit)
81{
82 RT_NOREF_PV(fReInit); RT_NOREF_PV(pvOpaque);
83 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
84 RTMd2Init((PRTMD2CONTEXT)pvState);
85 return VINF_SUCCESS;
86}
87
88/** MD2 alias ODIs. */
89static const char * const g_apszMd2Aliases[] =
90{
91 RTCR_PKCS1_MD2_WITH_RSA_OID,
92 "1.3.14.3.2.24" /* OIW md2WithRSASignature */,
93 NULL
94};
95
96/** MD2 descriptor. */
97static RTCRDIGESTDESC const g_rtCrDigestMd2Desc =
98{
99 "md2",
100 "1.2.840.113549.2.2",
101 g_apszMd2Aliases,
102 RTDIGESTTYPE_MD2,
103 RTMD2_HASH_SIZE,
104 sizeof(RTMD2CONTEXT),
105 RTCRDIGESTDESC_F_DEPRECATED,
106 NULL,
107 NULL,
108 rtCrDigestMd2_Update,
109 rtCrDigestMd2_Final,
110 rtCrDigestMd2_Init,
111 NULL,
112 NULL,
113 NULL,
114 NULL,
115};
116#endif /* !IPRT_WITHOUT_DIGEST_MD2 */
117
118
119/*
120 * MD4
121 */
122#ifndef IPRT_WITHOUT_DIGEST_MD4
123
124/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
125static DECLCALLBACK(void) rtCrDigestMd4_Update(void *pvState, const void *pvData, size_t cbData)
126{
127 RTMd4Update((PRTMD4CONTEXT)pvState, pvData, cbData);
128}
129
130/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
131static DECLCALLBACK(void) rtCrDigestMd4_Final(void *pvState, uint8_t *pbHash)
132{
133 RTMd4Final((PRTMD4CONTEXT)pvState, pbHash);
134}
135
136/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
137static DECLCALLBACK(int) rtCrDigestMd4_Init(void *pvState, void *pvOpaque, bool fReInit)
138{
139 RT_NOREF_PV(fReInit); RT_NOREF_PV(pvOpaque);
140 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
141 RTMd4Init((PRTMD4CONTEXT)pvState);
142 return VINF_SUCCESS;
143}
144
145/** MD4 alias ODIs. */
146static const char * const g_apszMd4Aliases[] =
147{
148 RTCR_PKCS1_MD4_WITH_RSA_OID,
149 NULL
150};
151
152/** MD4 descriptor. */
153static RTCRDIGESTDESC const g_rtCrDigestMd4Desc =
154{
155 "md4",
156 "1.2.840.113549.2.4",
157 g_apszMd4Aliases,
158 RTDIGESTTYPE_MD4,
159 RTMD4_HASH_SIZE,
160 sizeof(RTMD4CONTEXT),
161 RTCRDIGESTDESC_F_DEPRECATED | RTCRDIGESTDESC_F_COMPROMISED | RTCRDIGESTDESC_F_SERVERELY_COMPROMISED,
162 NULL,
163 NULL,
164 rtCrDigestMd4_Update,
165 rtCrDigestMd4_Final,
166 rtCrDigestMd4_Init,
167 NULL,
168 NULL,
169 NULL,
170 NULL,
171};
172
173#endif /* !IPRT_WITHOUT_DIGEST_MD4 */
174
175
176/*
177 * MD5
178 */
179#ifndef IPRT_WITHOUT_DIGEST_MD5
180
181/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
182static DECLCALLBACK(void) rtCrDigestMd5_Update(void *pvState, const void *pvData, size_t cbData)
183{
184 RTMd5Update((PRTMD5CONTEXT)pvState, pvData, cbData);
185}
186
187/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
188static DECLCALLBACK(void) rtCrDigestMd5_Final(void *pvState, uint8_t *pbHash)
189{
190 RTMd5Final(pbHash, (PRTMD5CONTEXT)pvState);
191}
192
193/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
194static DECLCALLBACK(int) rtCrDigestMd5_Init(void *pvState, void *pvOpaque, bool fReInit)
195{
196 RT_NOREF_PV(pvOpaque); RT_NOREF_PV(fReInit);
197 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
198 RTMd5Init((PRTMD5CONTEXT)pvState);
199 return VINF_SUCCESS;
200}
201
202/** MD5 alias ODIs. */
203static const char * const g_apszMd5Aliases[] =
204{
205 RTCR_PKCS1_MD5_WITH_RSA_OID,
206 "1.3.14.3.2.25" /* OIW md5WithRSASignature */,
207 NULL
208};
209
210/** MD5 descriptor. */
211static RTCRDIGESTDESC const g_rtCrDigestMd5Desc =
212{
213 "md5",
214 "1.2.840.113549.2.5",
215 g_apszMd5Aliases,
216 RTDIGESTTYPE_MD5,
217 RTMD5_HASH_SIZE,
218 sizeof(RTMD5CONTEXT),
219 RTCRDIGESTDESC_F_COMPROMISED,
220 NULL,
221 NULL,
222 rtCrDigestMd5_Update,
223 rtCrDigestMd5_Final,
224 rtCrDigestMd5_Init,
225 NULL,
226 NULL,
227 NULL,
228 NULL,
229};
230#endif /* !IPRT_WITHOUT_DIGEST_MD5 */
231
232
233/*
234 * SHA-1
235 */
236
237/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
238static DECLCALLBACK(void) rtCrDigestSha1_Update(void *pvState, const void *pvData, size_t cbData)
239{
240 RTSha1Update((PRTSHA1CONTEXT)pvState, pvData, cbData);
241}
242
243/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
244static DECLCALLBACK(void) rtCrDigestSha1_Final(void *pvState, uint8_t *pbHash)
245{
246 RTSha1Final((PRTSHA1CONTEXT)pvState, pbHash);
247}
248
249/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
250static DECLCALLBACK(int) rtCrDigestSha1_Init(void *pvState, void *pvOpaque, bool fReInit)
251{
252 RT_NOREF_PV(pvOpaque); RT_NOREF_PV(fReInit);
253 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
254 RTSha1Init((PRTSHA1CONTEXT)pvState);
255 return VINF_SUCCESS;
256}
257
258/** SHA-1 alias ODIs. */
259static const char * const g_apszSha1Aliases[] =
260{
261 RTCR_PKCS1_SHA1_WITH_RSA_OID,
262 "1.3.14.3.2.29" /* OIW sha1WithRSASignature */,
263 NULL
264};
265
266/** SHA-1 descriptor. */
267static RTCRDIGESTDESC const g_rtCrDigestSha1Desc =
268{
269 "sha-1",
270 "1.3.14.3.2.26",
271 g_apszSha1Aliases,
272 RTDIGESTTYPE_SHA1,
273 RTSHA1_HASH_SIZE,
274 sizeof(RTSHA1CONTEXT),
275 RTCRDIGESTDESC_F_DEPRECATED,
276 NULL,
277 NULL,
278 rtCrDigestSha1_Update,
279 rtCrDigestSha1_Final,
280 rtCrDigestSha1_Init,
281 NULL,
282 NULL,
283 NULL,
284 NULL,
285};
286
287
288/*
289 * SHA-256
290 */
291
292/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
293static DECLCALLBACK(void) rtCrDigestSha256_Update(void *pvState, const void *pvData, size_t cbData)
294{
295 RTSha256Update((PRTSHA256CONTEXT)pvState, pvData, cbData);
296}
297
298/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
299static DECLCALLBACK(void) rtCrDigestSha256_Final(void *pvState, uint8_t *pbHash)
300{
301 RTSha256Final((PRTSHA256CONTEXT)pvState, pbHash);
302}
303
304/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
305static DECLCALLBACK(int) rtCrDigestSha256_Init(void *pvState, void *pvOpaque, bool fReInit)
306{
307 RT_NOREF_PV(pvOpaque); RT_NOREF_PV(fReInit);
308 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
309 RTSha256Init((PRTSHA256CONTEXT)pvState);
310 return VINF_SUCCESS;
311}
312
313/** SHA-256 alias ODIs. */
314static const char * const g_apszSha256Aliases[] =
315{
316 RTCR_PKCS1_SHA256_WITH_RSA_OID,
317 NULL
318};
319
320/** SHA-256 descriptor. */
321static RTCRDIGESTDESC const g_rtCrDigestSha256Desc =
322{
323 "sha-256",
324 "2.16.840.1.101.3.4.2.1",
325 g_apszSha256Aliases,
326 RTDIGESTTYPE_SHA256,
327 RTSHA256_HASH_SIZE,
328 sizeof(RTSHA256CONTEXT),
329 0,
330 NULL,
331 NULL,
332 rtCrDigestSha256_Update,
333 rtCrDigestSha256_Final,
334 rtCrDigestSha256_Init,
335 NULL,
336 NULL,
337 NULL,
338 NULL,
339};
340
341
342/*
343 * SHA-512
344 */
345
346/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
347static DECLCALLBACK(void) rtCrDigestSha512_Update(void *pvState, const void *pvData, size_t cbData)
348{
349 RTSha512Update((PRTSHA512CONTEXT)pvState, pvData, cbData);
350}
351
352/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
353static DECLCALLBACK(void) rtCrDigestSha512_Final(void *pvState, uint8_t *pbHash)
354{
355 RTSha512Final((PRTSHA512CONTEXT)pvState, pbHash);
356}
357
358/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
359static DECLCALLBACK(int) rtCrDigestSha512_Init(void *pvState, void *pvOpaque, bool fReInit)
360{
361 RT_NOREF_PV(pvOpaque); RT_NOREF_PV(fReInit);
362 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
363 RTSha512Init((PRTSHA512CONTEXT)pvState);
364 return VINF_SUCCESS;
365}
366
367/** SHA-512 alias ODIs. */
368static const char * const g_apszSha512Aliases[] =
369{
370 RTCR_PKCS1_SHA512_WITH_RSA_OID,
371 NULL
372};
373
374/** SHA-512 descriptor. */
375static RTCRDIGESTDESC const g_rtCrDigestSha512Desc =
376{
377 "sha-512",
378 "2.16.840.1.101.3.4.2.3",
379 g_apszSha512Aliases,
380 RTDIGESTTYPE_SHA512,
381 RTSHA512_HASH_SIZE,
382 sizeof(RTSHA512CONTEXT),
383 0,
384 NULL,
385 NULL,
386 rtCrDigestSha512_Update,
387 rtCrDigestSha512_Final,
388 rtCrDigestSha512_Init,
389 NULL,
390 NULL,
391 NULL,
392 NULL,
393};
394
395
396/*
397 * SHA-224
398 */
399
400/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
401static DECLCALLBACK(void) rtCrDigestSha224_Update(void *pvState, const void *pvData, size_t cbData)
402{
403 RTSha224Update((PRTSHA224CONTEXT)pvState, pvData, cbData);
404}
405
406/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
407static DECLCALLBACK(void) rtCrDigestSha224_Final(void *pvState, uint8_t *pbHash)
408{
409 RTSha224Final((PRTSHA224CONTEXT)pvState, pbHash);
410}
411
412/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
413static DECLCALLBACK(int) rtCrDigestSha224_Init(void *pvState, void *pvOpaque, bool fReInit)
414{
415 RT_NOREF_PV(pvOpaque); RT_NOREF_PV(fReInit);
416 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
417 RTSha224Init((PRTSHA224CONTEXT)pvState);
418 return VINF_SUCCESS;
419}
420
421/** SHA-224 alias ODIs. */
422static const char * const g_apszSha224Aliases[] =
423{
424 RTCR_PKCS1_SHA224_WITH_RSA_OID,
425 NULL
426};
427
428/** SHA-224 descriptor. */
429static RTCRDIGESTDESC const g_rtCrDigestSha224Desc =
430{
431 "sha-224",
432 "2.16.840.1.101.3.4.2.4",
433 g_apszSha224Aliases,
434 RTDIGESTTYPE_SHA224,
435 RTSHA224_HASH_SIZE,
436 sizeof(RTSHA224CONTEXT),
437 0,
438 NULL,
439 NULL,
440 rtCrDigestSha224_Update,
441 rtCrDigestSha224_Final,
442 rtCrDigestSha224_Init,
443 NULL,
444 NULL,
445 NULL,
446 NULL,
447};
448
449
450/*
451 * SHA-384
452 */
453
454/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
455static DECLCALLBACK(void) rtCrDigestSha384_Update(void *pvState, const void *pvData, size_t cbData)
456{
457 RTSha384Update((PRTSHA384CONTEXT)pvState, pvData, cbData);
458}
459
460/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
461static DECLCALLBACK(void) rtCrDigestSha384_Final(void *pvState, uint8_t *pbHash)
462{
463 RTSha384Final((PRTSHA384CONTEXT)pvState, pbHash);
464}
465
466/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
467static DECLCALLBACK(int) rtCrDigestSha384_Init(void *pvState, void *pvOpaque, bool fReInit)
468{
469 RT_NOREF_PV(pvOpaque); RT_NOREF_PV(fReInit);
470 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
471 RTSha384Init((PRTSHA384CONTEXT)pvState);
472 return VINF_SUCCESS;
473}
474
475/** SHA-384 alias ODIs. */
476static const char * const g_apszSha384Aliases[] =
477{
478 RTCR_PKCS1_SHA384_WITH_RSA_OID,
479 NULL
480};
481
482/** SHA-384 descriptor. */
483static RTCRDIGESTDESC const g_rtCrDigestSha384Desc =
484{
485 "sha-384",
486 "2.16.840.1.101.3.4.2.2",
487 g_apszSha384Aliases,
488 RTDIGESTTYPE_SHA384,
489 RTSHA384_HASH_SIZE,
490 sizeof(RTSHA384CONTEXT),
491 0,
492 NULL,
493 NULL,
494 rtCrDigestSha384_Update,
495 rtCrDigestSha384_Final,
496 rtCrDigestSha384_Init,
497 NULL,
498 NULL,
499 NULL,
500 NULL,
501};
502
503
504#ifndef IPRT_WITHOUT_SHA512T224
505/*
506 * SHA-512/224
507 */
508
509/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
510static DECLCALLBACK(void) rtCrDigestSha512t224_Update(void *pvState, const void *pvData, size_t cbData)
511{
512 RTSha512t224Update((PRTSHA512T224CONTEXT)pvState, pvData, cbData);
513}
514
515/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
516static DECLCALLBACK(void) rtCrDigestSha512t224_Final(void *pvState, uint8_t *pbHash)
517{
518 RTSha512t224Final((PRTSHA512T224CONTEXT)pvState, pbHash);
519}
520
521/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
522static DECLCALLBACK(int) rtCrDigestSha512t224_Init(void *pvState, void *pvOpaque, bool fReInit)
523{
524 RT_NOREF_PV(pvOpaque); RT_NOREF_PV(fReInit);
525 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
526 RTSha512t224Init((PRTSHA512T224CONTEXT)pvState);
527 return VINF_SUCCESS;
528}
529
530/** SHA-512/224 alias ODIs. */
531static const char * const g_apszSha512t224Aliases[] =
532{
533 RTCR_PKCS1_SHA512T224_WITH_RSA_OID,
534 NULL
535};
536
537/** SHA-512/224 descriptor. */
538static RTCRDIGESTDESC const g_rtCrDigestSha512t224Desc =
539{
540 "sha-512/224",
541 "2.16.840.1.101.3.4.2.5",
542 g_apszSha512t224Aliases,
543 RTDIGESTTYPE_SHA512T224,
544 RTSHA512T224_HASH_SIZE,
545 sizeof(RTSHA512T224CONTEXT),
546 0,
547 NULL,
548 NULL,
549 rtCrDigestSha512t224_Update,
550 rtCrDigestSha512t224_Final,
551 rtCrDigestSha512t224_Init,
552 NULL,
553 NULL,
554 NULL,
555 NULL,
556};
557#endif /* !IPRT_WITHOUT_SHA512T224 */
558
559
560#ifndef IPRT_WITHOUT_SHA512T256
561/*
562 * SHA-512/256
563 */
564
565/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
566static DECLCALLBACK(void) rtCrDigestSha512t256_Update(void *pvState, const void *pvData, size_t cbData)
567{
568 RTSha512t256Update((PRTSHA512T256CONTEXT)pvState, pvData, cbData);
569}
570
571/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
572static DECLCALLBACK(void) rtCrDigestSha512t256_Final(void *pvState, uint8_t *pbHash)
573{
574 RTSha512t256Final((PRTSHA512T256CONTEXT)pvState, pbHash);
575}
576
577/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
578static DECLCALLBACK(int) rtCrDigestSha512t256_Init(void *pvState, void *pvOpaque, bool fReInit)
579{
580 RT_NOREF_PV(pvOpaque); RT_NOREF_PV(fReInit);
581 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
582 RTSha512t256Init((PRTSHA512T256CONTEXT)pvState);
583 return VINF_SUCCESS;
584}
585
586/** SHA-512/256 alias ODIs. */
587static const char * const g_apszSha512t256Aliases[] =
588{
589 RTCR_PKCS1_SHA512T256_WITH_RSA_OID,
590 NULL
591};
592
593/** SHA-512/256 descriptor. */
594static RTCRDIGESTDESC const g_rtCrDigestSha512t256Desc =
595{
596 "sha-512/256",
597 "2.16.840.1.101.3.4.2.6",
598 g_apszSha512t256Aliases,
599 RTDIGESTTYPE_SHA512T256,
600 RTSHA512T256_HASH_SIZE,
601 sizeof(RTSHA512T256CONTEXT),
602 0,
603 NULL,
604 NULL,
605 rtCrDigestSha512t256_Update,
606 rtCrDigestSha512t256_Final,
607 rtCrDigestSha512t256_Init,
608 NULL,
609 NULL,
610 NULL,
611 NULL,
612};
613#endif /* !IPRT_WITHOUT_SHA512T256 */
614
615#ifndef IPRT_WITHOUT_SHA3
616
617/*
618 * SHA3-224
619 */
620
621/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
622static DECLCALLBACK(void) rtCrDigestSha3t224_Update(void *pvState, const void *pvData, size_t cbData)
623{
624 int rc = RTSha3t224Update((PRTSHA3T224CONTEXT)pvState, pvData, cbData);
625 AssertRC(rc);
626}
627
628/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
629static DECLCALLBACK(void) rtCrDigestSha3t224_Final(void *pvState, uint8_t *pbHash)
630{
631 int rc = RTSha3t224Final((PRTSHA3T224CONTEXT)pvState, pbHash);
632 AssertRC(rc);
633}
634
635/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
636static DECLCALLBACK(int) rtCrDigestSha3t224_Init(void *pvState, void *pvOpaque, bool fReInit)
637{
638 RT_NOREF_PV(pvOpaque);
639 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
640 if (fReInit)
641 RTSha3t224Cleanup((PRTSHA3T224CONTEXT)pvState);
642 return RTSha3t224Init((PRTSHA3T224CONTEXT)pvState);
643}
644
645/** @impl_interface_method{RTCRDIGESTDESC::pfnDelete} */
646static DECLCALLBACK(void) rtCrDigestSha3t224_Delete(void *pvState)
647{
648 RTSha3t224Cleanup((PRTSHA3T224CONTEXT)pvState);
649}
650
651/** @impl_interface_method{RTCRDIGESTDESC::pfnDelete} */
652static DECLCALLBACK(int) rtCrDigestSha3t224_Clone(void *pvState, void const *pvSrcState)
653{
654 return RTSha3t224Clone((PRTSHA3T224CONTEXT)pvState, (PRTSHA3T224CONTEXT)pvSrcState);
655}
656
657/** SHA3-224 alias ODIs. */
658static const char * const g_apszSha3t224Aliases[] =
659{
660 "2.16.840.1.101.3.4.3.13",
661 NULL
662};
663
664/** SHA3-224 descriptor. */
665static RTCRDIGESTDESC const g_rtCrDigestSha3t224Desc =
666{
667 "sha3-224",
668 "2.16.840.1.101.3.4.2.7",
669 g_apszSha3t224Aliases,
670 RTDIGESTTYPE_SHA3_224,
671 RTSHA3_224_HASH_SIZE,
672 sizeof(RTSHA3T224CONTEXT),
673 0,
674 NULL,
675 NULL,
676 rtCrDigestSha3t224_Update,
677 rtCrDigestSha3t224_Final,
678 rtCrDigestSha3t224_Init,
679 rtCrDigestSha3t224_Delete,
680 rtCrDigestSha3t224_Clone,
681 NULL,
682 NULL,
683};
684
685
686/*
687 * SHA3-256
688 */
689
690/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
691static DECLCALLBACK(void) rtCrDigestSha3t256_Update(void *pvState, const void *pvData, size_t cbData)
692{
693 int rc = RTSha3t256Update((PRTSHA3T256CONTEXT)pvState, pvData, cbData);
694 AssertRC(rc);
695}
696
697/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
698static DECLCALLBACK(void) rtCrDigestSha3t256_Final(void *pvState, uint8_t *pbHash)
699{
700 int rc = RTSha3t256Final((PRTSHA3T256CONTEXT)pvState, pbHash);
701 AssertRC(rc);
702}
703
704/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
705static DECLCALLBACK(int) rtCrDigestSha3t256_Init(void *pvState, void *pvOpaque, bool fReInit)
706{
707 RT_NOREF_PV(pvOpaque);
708 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
709 if (fReInit)
710 RTSha3t256Cleanup((PRTSHA3T256CONTEXT)pvState);
711 return RTSha3t256Init((PRTSHA3T256CONTEXT)pvState);
712}
713
714/** @impl_interface_method{RTCRDIGESTDESC::pfnDelete} */
715static DECLCALLBACK(void) rtCrDigestSha3t256_Delete(void *pvState)
716{
717 RTSha3t256Cleanup((PRTSHA3T256CONTEXT)pvState);
718}
719
720/** @impl_interface_method{RTCRDIGESTDESC::pfnDelete} */
721static DECLCALLBACK(int) rtCrDigestSha3t256_Clone(void *pvState, void const *pvSrcState)
722{
723 return RTSha3t256Clone((PRTSHA3T256CONTEXT)pvState, (PRTSHA3T256CONTEXT)pvSrcState);
724}
725
726/** SHA3-256 alias ODIs. */
727static const char * const g_apszSha3t256Aliases[] =
728{
729 "2.16.840.1.101.3.4.3.14",
730 NULL
731};
732
733/** SHA3-256 descriptor. */
734static RTCRDIGESTDESC const g_rtCrDigestSha3t256Desc =
735{
736 "sha3-256",
737 "2.16.840.1.101.3.4.2.8",
738 g_apszSha3t256Aliases,
739 RTDIGESTTYPE_SHA3_256,
740 RTSHA3_256_HASH_SIZE,
741 sizeof(RTSHA3T256CONTEXT),
742 0,
743 NULL,
744 NULL,
745 rtCrDigestSha3t256_Update,
746 rtCrDigestSha3t256_Final,
747 rtCrDigestSha3t256_Init,
748 rtCrDigestSha3t256_Delete,
749 rtCrDigestSha3t256_Clone,
750 NULL,
751 NULL,
752};
753
754
755/*
756 * SHA3-384
757 */
758
759/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
760static DECLCALLBACK(void) rtCrDigestSha3t384_Update(void *pvState, const void *pvData, size_t cbData)
761{
762 int rc = RTSha3t384Update((PRTSHA3T384CONTEXT)pvState, pvData, cbData);
763 AssertRC(rc);
764}
765
766/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
767static DECLCALLBACK(void) rtCrDigestSha3t384_Final(void *pvState, uint8_t *pbHash)
768{
769 int rc = RTSha3t384Final((PRTSHA3T384CONTEXT)pvState, pbHash);
770 AssertRC(rc);
771}
772
773/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
774static DECLCALLBACK(int) rtCrDigestSha3t384_Init(void *pvState, void *pvOpaque, bool fReInit)
775{
776 RT_NOREF_PV(pvOpaque);
777 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
778 if (fReInit)
779 RTSha3t384Cleanup((PRTSHA3T384CONTEXT)pvState);
780 return RTSha3t384Init((PRTSHA3T384CONTEXT)pvState);
781}
782
783/** @impl_interface_method{RTCRDIGESTDESC::pfnDelete} */
784static DECLCALLBACK(void) rtCrDigestSha3t384_Delete(void *pvState)
785{
786 RTSha3t384Cleanup((PRTSHA3T384CONTEXT)pvState);
787}
788
789/** @impl_interface_method{RTCRDIGESTDESC::pfnDelete} */
790static DECLCALLBACK(int) rtCrDigestSha3t384_Clone(void *pvState, void const *pvSrcState)
791{
792 return RTSha3t384Clone((PRTSHA3T384CONTEXT)pvState, (PRTSHA3T384CONTEXT)pvSrcState);
793}
794
795/** SHA3-384 alias ODIs. */
796static const char * const g_apszSha3t384Aliases[] =
797{
798 "2.16.840.1.101.3.4.3.15",
799 NULL
800};
801
802/** SHA3-384 descriptor. */
803static RTCRDIGESTDESC const g_rtCrDigestSha3t384Desc =
804{
805 "sha3-384",
806 "2.16.840.1.101.3.4.2.9",
807 g_apszSha3t384Aliases,
808 RTDIGESTTYPE_SHA3_384,
809 RTSHA3_384_HASH_SIZE,
810 sizeof(RTSHA3T384CONTEXT),
811 0,
812 NULL,
813 NULL,
814 rtCrDigestSha3t384_Update,
815 rtCrDigestSha3t384_Final,
816 rtCrDigestSha3t384_Init,
817 rtCrDigestSha3t384_Delete,
818 rtCrDigestSha3t384_Clone,
819 NULL,
820 NULL,
821};
822
823
824/*
825 * SHA3-512
826 */
827
828/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
829static DECLCALLBACK(void) rtCrDigestSha3t512_Update(void *pvState, const void *pvData, size_t cbData)
830{
831 int rc = RTSha3t512Update((PRTSHA3T512CONTEXT)pvState, pvData, cbData);
832 AssertRC(rc);
833}
834
835/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
836static DECLCALLBACK(void) rtCrDigestSha3t512_Final(void *pvState, uint8_t *pbHash)
837{
838 int rc = RTSha3t512Final((PRTSHA3T512CONTEXT)pvState, pbHash);
839 AssertRC(rc);
840}
841
842/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
843static DECLCALLBACK(int) rtCrDigestSha3t512_Init(void *pvState, void *pvOpaque, bool fReInit)
844{
845 RT_NOREF_PV(pvOpaque);
846 AssertReturn(pvOpaque == NULL, VERR_INVALID_PARAMETER);
847 if (fReInit)
848 RTSha3t512Cleanup((PRTSHA3T512CONTEXT)pvState);
849 return RTSha3t512Init((PRTSHA3T512CONTEXT)pvState);
850}
851
852/** @impl_interface_method{RTCRDIGESTDESC::pfnDelete} */
853static DECLCALLBACK(void) rtCrDigestSha3t512_Delete(void *pvState)
854{
855 RTSha3t512Cleanup((PRTSHA3T512CONTEXT)pvState);
856}
857
858/** @impl_interface_method{RTCRDIGESTDESC::pfnDelete} */
859static DECLCALLBACK(int) rtCrDigestSha3t512_Clone(void *pvState, void const *pvSrcState)
860{
861 return RTSha3t512Clone((PRTSHA3T512CONTEXT)pvState, (PRTSHA3T512CONTEXT)pvSrcState);
862}
863
864/** SHA3-512 alias ODIs. */
865static const char * const g_apszSha3t512Aliases[] =
866{
867 "2.16.840.1.101.3.4.3.16",
868 NULL
869};
870
871/** SHA3-512 descriptor. */
872static RTCRDIGESTDESC const g_rtCrDigestSha3t512Desc =
873{
874 "sha3-512",
875 "2.16.840.1.101.3.4.2.10",
876 g_apszSha3t512Aliases,
877 RTDIGESTTYPE_SHA3_512,
878 RTSHA3_512_HASH_SIZE,
879 sizeof(RTSHA3T512CONTEXT),
880 0,
881 NULL,
882 NULL,
883 rtCrDigestSha3t512_Update,
884 rtCrDigestSha3t512_Final,
885 rtCrDigestSha3t512_Init,
886 rtCrDigestSha3t512_Delete,
887 rtCrDigestSha3t512_Clone,
888 NULL,
889 NULL,
890};
891
892#endif /* !IPRT_WITHOUT_SHA3 */
893
894
895/**
896 * Array of built in message digest vtables.
897 */
898static PCRTCRDIGESTDESC const g_apDigestOps[] =
899{
900#ifndef IPRT_WITHOUT_DIGEST_MD2
901 &g_rtCrDigestMd2Desc,
902#endif
903#ifndef IPRT_WITHOUT_DIGEST_MD4
904 &g_rtCrDigestMd4Desc,
905#endif
906#ifndef IPRT_WITHOUT_DIGEST_MD5
907 &g_rtCrDigestMd5Desc,
908#endif
909 &g_rtCrDigestSha1Desc,
910 &g_rtCrDigestSha256Desc,
911 &g_rtCrDigestSha512Desc,
912 &g_rtCrDigestSha224Desc,
913 &g_rtCrDigestSha384Desc,
914#ifndef IPRT_WITHOUT_SHA512T224
915 &g_rtCrDigestSha512t224Desc,
916#endif
917#ifndef IPRT_WITHOUT_SHA512T256
918 &g_rtCrDigestSha512t256Desc,
919#endif
920#ifndef IPRT_WITHOUT_SHA3
921 &g_rtCrDigestSha3t224Desc,
922 &g_rtCrDigestSha3t256Desc,
923 &g_rtCrDigestSha3t384Desc,
924 &g_rtCrDigestSha3t512Desc,
925#endif
926};
927
928
929#ifdef IPRT_WITH_OPENSSL
930/*
931 * OpenSSL EVP.
932 */
933
934# if OPENSSL_VERSION_NUMBER >= 0x10100000 && !defined(LIBRESSL_VERSION_NUMBER)
935/** @impl_interface_method{RTCRDIGESTDESC::pfnNew} */
936static DECLCALLBACK(void*) rtCrDigestOsslEvp_New(void)
937{
938 return EVP_MD_CTX_new();
939}
940
941static DECLCALLBACK(void) rtCrDigestOsslEvp_Free(void *pvState)
942{
943 EVP_MD_CTX_free((EVP_MD_CTX*)pvState);
944}
945
946# endif
947
948/** @impl_interface_method{RTCRDIGESTDESC::pfnUpdate} */
949static DECLCALLBACK(void) rtCrDigestOsslEvp_Update(void *pvState, const void *pvData, size_t cbData)
950{
951 EVP_DigestUpdate((EVP_MD_CTX *)pvState, pvData, cbData);
952}
953
954/** @impl_interface_method{RTCRDIGESTDESC::pfnFinal} */
955static DECLCALLBACK(void) rtCrDigestOsslEvp_Final(void *pvState, uint8_t *pbHash)
956{
957 unsigned int cbHash = EVP_MAX_MD_SIZE;
958 EVP_DigestFinal((EVP_MD_CTX *)pvState, (unsigned char *)pbHash, &cbHash);
959}
960
961/** @impl_interface_method{RTCRDIGESTDESC::pfnInit} */
962static DECLCALLBACK(int) rtCrDigestOsslEvp_Init(void *pvState, void *pvOpaque, bool fReInit)
963{
964 EVP_MD_CTX *pThis = (EVP_MD_CTX *)pvState;
965 EVP_MD const *pEvpType = (EVP_MD const *)pvOpaque;
966
967 if (fReInit)
968 {
969 pEvpType = EVP_MD_CTX_md(pThis);
970# if OPENSSL_VERSION_NUMBER >= 0x10100000 && !defined(LIBRESSL_VERSION_NUMBER)
971 EVP_MD_CTX_reset(pThis);
972# else
973 EVP_MD_CTX_cleanup(pThis);
974# endif
975 }
976
977 AssertPtrReturn(pEvpType, VERR_INVALID_PARAMETER);
978# if OPENSSL_VERSION_NUMBER >= 0x10100000 && !defined(LIBRESSL_VERSION_NUMBER)
979 Assert(EVP_MD_block_size(pEvpType));
980# else
981 Assert(pEvpType->md_size);
982# endif
983 if (EVP_DigestInit(pThis, pEvpType))
984 return VINF_SUCCESS;
985 return VERR_CR_DIGEST_OSSL_DIGEST_INIT_ERROR;
986}
987
988
989/** @impl_interface_method{RTCRDIGESTDESC::pfn} */
990static DECLCALLBACK(void) rtCrDigestOsslEvp_Delete(void *pvState)
991{
992 EVP_MD_CTX *pThis = (EVP_MD_CTX *)pvState;
993# if OPENSSL_VERSION_NUMBER >= 0x10100000 && !defined(LIBRESSL_VERSION_NUMBER)
994 EVP_MD_CTX_reset(pThis);
995# else
996 EVP_MD_CTX_cleanup(pThis);
997# endif
998}
999
1000
1001/** @impl_interface_method{RTCRDIGESTDESC::pfnClone} */
1002static DECLCALLBACK(int) rtCrDigestOsslEvp_Clone(void *pvState, void const *pvSrcState)
1003{
1004 EVP_MD_CTX *pThis = (EVP_MD_CTX *)pvState;
1005 EVP_MD_CTX const *pSrc = (EVP_MD_CTX const *)pvSrcState;
1006
1007 if (EVP_MD_CTX_copy(pThis, pSrc))
1008 return VINF_SUCCESS;
1009 return VERR_CR_DIGEST_OSSL_DIGEST_CTX_COPY_ERROR;
1010}
1011
1012
1013/** @impl_interface_method{RTCRDIGESTDESC::pfnGetHashSize} */
1014static DECLCALLBACK(uint32_t) rtCrDigestOsslEvp_GetHashSize(void *pvState)
1015{
1016 EVP_MD_CTX *pThis = (EVP_MD_CTX *)pvState;
1017 return EVP_MD_size(EVP_MD_CTX_md(pThis));
1018}
1019
1020
1021/** @impl_interface_method{RTCRDIGESTDESC::pfnGetHashSize} */
1022static DECLCALLBACK(RTDIGESTTYPE) rtCrDigestOsslEvp_GetDigestType(void *pvState)
1023{
1024 RT_NOREF_PV(pvState); //EVP_MD_CTX *pThis = (EVP_MD_CTX *)pvState;
1025 /** @todo figure which digest algorithm it is! */
1026 return RTDIGESTTYPE_UNKNOWN;
1027}
1028
1029
1030/** Descriptor for the OpenSSL EVP base message digest provider. */
1031static RTCRDIGESTDESC const g_rtCrDigestOpenSslDesc =
1032{
1033 "OpenSSL EVP",
1034 NULL,
1035 NULL,
1036 RTDIGESTTYPE_UNKNOWN,
1037 EVP_MAX_MD_SIZE,
1038# if OPENSSL_VERSION_NUMBER >= 0x10100000 && !defined(LIBRESSL_VERSION_NUMBER)
1039 0,
1040# else
1041 sizeof(EVP_MD_CTX),
1042# endif
1043 0,
1044# if OPENSSL_VERSION_NUMBER >= 0x10100000 && !defined(LIBRESSL_VERSION_NUMBER)
1045 rtCrDigestOsslEvp_New,
1046 rtCrDigestOsslEvp_Free,
1047# else
1048 NULL,
1049 NULL,
1050# endif
1051 rtCrDigestOsslEvp_Update,
1052 rtCrDigestOsslEvp_Final,
1053 rtCrDigestOsslEvp_Init,
1054 rtCrDigestOsslEvp_Delete,
1055 rtCrDigestOsslEvp_Clone,
1056 rtCrDigestOsslEvp_GetHashSize,
1057 rtCrDigestOsslEvp_GetDigestType
1058};
1059
1060#endif /* IPRT_WITH_OPENSSL */
1061
1062
1063RTDECL(PCRTCRDIGESTDESC) RTCrDigestFindByObjIdString(const char *pszObjId, void **ppvOpaque)
1064{
1065 if (ppvOpaque)
1066 *ppvOpaque = NULL;
1067
1068 /*
1069 * Primary OIDs.
1070 */
1071 uint32_t i = RT_ELEMENTS(g_apDigestOps);
1072 while (i-- > 0)
1073 if (strcmp(g_apDigestOps[i]->pszObjId, pszObjId) == 0)
1074 return g_apDigestOps[i];
1075
1076 /*
1077 * Alias OIDs.
1078 */
1079 i = RT_ELEMENTS(g_apDigestOps);
1080 while (i-- > 0)
1081 {
1082 const char * const *ppszAliases = g_apDigestOps[i]->papszObjIdAliases;
1083 if (ppszAliases)
1084 for (; *ppszAliases; ppszAliases++)
1085 if (strcmp(*ppszAliases, pszObjId) == 0)
1086 return g_apDigestOps[i];
1087 }
1088
1089#ifdef IPRT_WITH_OPENSSL
1090 /*
1091 * Try EVP and see if it knows the algorithm.
1092 */
1093 if (ppvOpaque)
1094 {
1095 rtCrOpenSslInit();
1096 int iAlgoNid = OBJ_txt2nid(pszObjId);
1097 if (iAlgoNid != NID_undef)
1098 {
1099 const char *pszAlogSn = OBJ_nid2sn(iAlgoNid);
1100 const EVP_MD *pEvpMdType = EVP_get_digestbyname(pszAlogSn);
1101 if (pEvpMdType)
1102 {
1103 /*
1104 * Return the OpenSSL provider descriptor and the EVP_MD address.
1105 */
1106# if OPENSSL_VERSION_NUMBER >= 0x10100000 && !defined(LIBRESSL_VERSION_NUMBER)
1107 Assert(EVP_MD_block_size(pEvpMdType));
1108# else
1109 Assert(pEvpMdType->md_size);
1110# endif
1111 *ppvOpaque = (void *)pEvpMdType;
1112 return &g_rtCrDigestOpenSslDesc;
1113 }
1114 }
1115 }
1116#endif
1117 return NULL;
1118}
1119
1120
1121RTDECL(PCRTCRDIGESTDESC) RTCrDigestFindByObjId(PCRTASN1OBJID pObjId, void **ppvOpaque)
1122{
1123 return RTCrDigestFindByObjIdString(pObjId->szObjId, ppvOpaque);
1124}
1125
1126
1127RTDECL(int) RTCrDigestCreateByObjIdString(PRTCRDIGEST phDigest, const char *pszObjId)
1128{
1129 void *pvOpaque;
1130 PCRTCRDIGESTDESC pDesc = RTCrDigestFindByObjIdString(pszObjId, &pvOpaque);
1131 if (pDesc)
1132 return RTCrDigestCreate(phDigest, pDesc, pvOpaque);
1133 return VERR_NOT_FOUND;
1134}
1135
1136
1137RTDECL(int) RTCrDigestCreateByObjId(PRTCRDIGEST phDigest, PCRTASN1OBJID pObjId)
1138{
1139 void *pvOpaque;
1140 PCRTCRDIGESTDESC pDesc = RTCrDigestFindByObjId(pObjId, &pvOpaque);
1141 if (pDesc)
1142 return RTCrDigestCreate(phDigest, pDesc, pvOpaque);
1143 return VERR_NOT_FOUND;
1144}
1145
1146
1147RTDECL(PCRTCRDIGESTDESC) RTCrDigestFindByType(RTDIGESTTYPE enmDigestType)
1148{
1149 AssertReturn(enmDigestType > RTDIGESTTYPE_INVALID && enmDigestType <= RTDIGESTTYPE_END, NULL);
1150
1151 uint32_t i = RT_ELEMENTS(g_apDigestOps);
1152 while (i-- > 0)
1153 if (g_apDigestOps[i]->enmType == enmDigestType)
1154 return g_apDigestOps[i];
1155 return NULL;
1156}
1157
1158
1159RTDECL(int) RTCrDigestCreateByType(PRTCRDIGEST phDigest, RTDIGESTTYPE enmDigestType)
1160{
1161 PCRTCRDIGESTDESC pDesc = RTCrDigestFindByType(enmDigestType);
1162 if (pDesc)
1163 return RTCrDigestCreate(phDigest, pDesc, NULL);
1164 return VERR_NOT_FOUND;
1165}
1166
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette