VirtualBox

source: vbox/trunk/include/iprt/sha.h

Last change on this file was 98103, checked in by vboxsync, 16 months ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.6 KB
Line 
1/** @file
2 * IPRT - SHA1 digest creation
3 */
4
5/*
6 * Copyright (C) 2009-2023 Oracle and/or its affiliates.
7 *
8 * This file is part of VirtualBox base platform packages, as
9 * available from https://www.virtualbox.org.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation, in version 3 of the
14 * License.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, see <https://www.gnu.org/licenses>.
23 *
24 * The contents of this file may alternatively be used under the terms
25 * of the Common Development and Distribution License Version 1.0
26 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
27 * in the VirtualBox distribution, in which case the provisions of the
28 * CDDL are applicable instead of those of the GPL.
29 *
30 * You may elect to license modified versions of this file under the
31 * terms and conditions of either the GPL or the CDDL or both.
32 *
33 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
34 */
35
36#ifndef IPRT_INCLUDED_sha_h
37#define IPRT_INCLUDED_sha_h
38#ifndef RT_WITHOUT_PRAGMA_ONCE
39# pragma once
40#endif
41
42#include <iprt/types.h>
43
44RT_C_DECLS_BEGIN
45
46/** @defgroup grp_rt_sha RTSha - SHA Family of Hash Functions
47 * @ingroup grp_rt
48 * @{
49 */
50
51/** The size of a SHA-1 hash. */
52#define RTSHA1_HASH_SIZE 20
53/** The length of a SHA-1 digest string. The terminator is not included. */
54#define RTSHA1_DIGEST_LEN 40
55
56/**
57 * SHA-1 context.
58 */
59typedef union RTSHA1CONTEXT
60{
61 uint64_t u64BetterAlignment;
62 uint8_t abPadding[8 + (5 + 80) * 4 + 4];
63#ifdef RT_SHA1_PRIVATE_CONTEXT
64 SHA_CTX Private;
65#endif
66#ifdef RT_SHA1_PRIVATE_ALT_CONTEXT
67 RTSHA1ALTPRIVATECTX AltPrivate;
68#endif
69} RTSHA1CONTEXT;
70/** Pointer to an SHA-1 context. */
71typedef RTSHA1CONTEXT *PRTSHA1CONTEXT;
72
73/**
74 * Compute the SHA-1 hash of the data.
75 *
76 * @param pvBuf Pointer to the data.
77 * @param cbBuf The amount of data (in bytes).
78 * @param pabHash Where to store the hash. (What is passed is a pointer to
79 * the caller's buffer.)
80 */
81RTDECL(void) RTSha1(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RTSHA1_HASH_SIZE]);
82
83/**
84 * Computes the SHA-1 hash for the given data comparing it with the one given.
85 *
86 * @returns true on match, false on mismatch.
87 * @param pvBuf Pointer to the data.
88 * @param cbBuf The amount of data (in bytes).
89 * @param pabHash The hash to verify. (What is passed is a pointer to the
90 * caller's buffer.)
91 */
92RTDECL(bool) RTSha1Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA1_HASH_SIZE]);
93
94/**
95 * Initializes the SHA-1 context.
96 *
97 * @param pCtx Pointer to the SHA-1 context.
98 */
99RTDECL(void) RTSha1Init(PRTSHA1CONTEXT pCtx);
100
101/**
102 * Feed data into the SHA-1 computation.
103 *
104 * @param pCtx Pointer to the SHA-1 context.
105 * @param pvBuf Pointer to the data.
106 * @param cbBuf The length of the data (in bytes).
107 */
108RTDECL(void) RTSha1Update(PRTSHA1CONTEXT pCtx, const void *pvBuf, size_t cbBuf);
109
110/**
111 * Compute the SHA-1 hash of the data.
112 *
113 * @param pCtx Pointer to the SHA-1 context.
114 * @param pabHash Where to store the hash. (What is passed is a pointer to
115 * the caller's buffer.)
116 */
117RTDECL(void) RTSha1Final(PRTSHA1CONTEXT pCtx, uint8_t pabHash[RTSHA1_HASH_SIZE]);
118
119/**
120 * Converts a SHA-1 hash to a digest string.
121 *
122 * @returns IPRT status code.
123 *
124 * @param pabHash The binary digest returned by RTSha1Final or RTSha1.
125 * @param pszDigest Where to return the stringified digest.
126 * @param cchDigest The size of the output buffer. Should be at least
127 * RTSHA1_DIGEST_LEN + 1 bytes.
128 */
129RTDECL(int) RTSha1ToString(uint8_t const pabHash[RTSHA1_HASH_SIZE], char *pszDigest, size_t cchDigest);
130
131/**
132 * Converts a SHA-1 hash to a digest string.
133 *
134 * @returns IPRT status code.
135 *
136 * @param pszDigest The stringified digest. Leading and trailing spaces are
137 * ignored.
138 * @param pabHash Where to store the hash. (What is passed is a pointer to
139 * the caller's buffer.)
140 */
141RTDECL(int) RTSha1FromString(char const *pszDigest, uint8_t pabHash[RTSHA1_HASH_SIZE]);
142
143/**
144 * Creates a SHA1 digest for the given memory buffer.
145 *
146 * @returns iprt status code.
147 *
148 * @param pvBuf Memory buffer to create a SHA1 digest for.
149 * @param cbBuf The amount of data (in bytes).
150 * @param ppszDigest On success the SHA1 digest.
151 * @param pfnProgressCallback optional callback for the progress indication
152 * @param pvUser user defined pointer for the callback
153 */
154RTR3DECL(int) RTSha1Digest(void* pvBuf, size_t cbBuf, char **ppszDigest, PFNRTPROGRESS pfnProgressCallback, void *pvUser);
155
156/**
157 * Creates a SHA1 digest for the given file.
158 *
159 * @returns iprt status code.
160 *
161 * @param pszFile Filename to create a SHA1 digest for.
162 * @param ppszDigest On success the SHA1 digest.
163 * @param pfnProgressCallback optional callback for the progress indication
164 * @param pvUser user defined pointer for the callback
165 */
166RTR3DECL(int) RTSha1DigestFromFile(const char *pszFile, char **ppszDigest, PFNRTPROGRESS pfnProgressCallback, void *pvUser);
167
168
169
170/** The size of a SHA-256 hash. */
171#define RTSHA256_HASH_SIZE 32
172/** The length of a SHA-256 digest string. The terminator is not included. */
173#define RTSHA256_DIGEST_LEN 64
174
175/**
176 * SHA-256 context.
177 */
178typedef union RTSHA256CONTEXT
179{
180 uint64_t u64BetterAlignment;
181 uint8_t abPadding[8 + (8 + 80) * 4];
182#ifdef RT_SHA256_PRIVATE_CONTEXT
183 SHA256_CTX Private;
184#endif
185#ifdef RT_SHA256_PRIVATE_ALT_CONTEXT
186 RTSHA256ALTPRIVATECTX AltPrivate;
187#endif
188} RTSHA256CONTEXT;
189/** Pointer to an SHA-256 context. */
190typedef RTSHA256CONTEXT *PRTSHA256CONTEXT;
191
192/**
193 * Compute the SHA-256 hash of the data.
194 *
195 * @param pvBuf Pointer to the data.
196 * @param cbBuf The amount of data (in bytes).
197 * @param pabHash Where to store the hash. (What is passed is a pointer to
198 * the caller's buffer.)
199 */
200RTDECL(void) RTSha256(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RTSHA256_HASH_SIZE]);
201
202/**
203 * Computes the SHA-256 hash for the given data comparing it with the one given.
204 *
205 * @returns true on match, false on mismatch.
206 * @param pvBuf Pointer to the data.
207 * @param cbBuf The amount of data (in bytes).
208 * @param pabHash The hash to verify. (What is passed is a pointer to the
209 * caller's buffer.)
210 */
211RTDECL(bool) RTSha256Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA256_HASH_SIZE]);
212
213/**
214 * Initializes the SHA-256 context.
215 *
216 * @param pCtx Pointer to the SHA-256 context.
217 */
218RTDECL(void) RTSha256Init(PRTSHA256CONTEXT pCtx);
219
220/**
221 * Feed data into the SHA-256 computation.
222 *
223 * @param pCtx Pointer to the SHA-256 context.
224 * @param pvBuf Pointer to the data.
225 * @param cbBuf The length of the data (in bytes).
226 */
227RTDECL(void) RTSha256Update(PRTSHA256CONTEXT pCtx, const void *pvBuf, size_t cbBuf);
228
229/**
230 * Compute the SHA-256 hash of the data.
231 *
232 * @param pCtx Pointer to the SHA-256 context.
233 * @param pabHash Where to store the hash. (What is passed is a pointer to
234 * the caller's buffer.)
235 */
236RTDECL(void) RTSha256Final(PRTSHA256CONTEXT pCtx, uint8_t pabHash[RTSHA256_HASH_SIZE]);
237
238/**
239 * Converts a SHA-256 hash to a digest string.
240 *
241 * @returns IPRT status code.
242 *
243 * @param pabHash The binary digest returned by RTSha256Final or RTSha256.
244 * @param pszDigest Where to return the stringified digest.
245 * @param cchDigest The size of the output buffer. Should be at least
246 * RTSHA256_DIGEST_LEN + 1 bytes.
247 */
248RTDECL(int) RTSha256ToString(uint8_t const pabHash[RTSHA256_HASH_SIZE], char *pszDigest, size_t cchDigest);
249
250/**
251 * Converts a SHA-256 hash to a digest string.
252 *
253 * @returns IPRT status code.
254 *
255 * @param pszDigest The stringified digest. Leading and trailing spaces are
256 * ignored.
257 * @param pabHash Where to store the hash. (What is passed is a pointer to
258 * the caller's buffer.)
259 */
260RTDECL(int) RTSha256FromString(char const *pszDigest, uint8_t pabHash[RTSHA256_HASH_SIZE]);
261
262/**
263 * Creates a SHA256 digest for the given memory buffer.
264 *
265 * @returns iprt status code.
266 *
267 * @param pvBuf Memory buffer to create a
268 * SHA256 digest for.
269 * @param cbBuf The amount of data (in bytes).
270 * @param ppszDigest On success the SHA256 digest.
271 * @param pfnProgressCallback optional callback for the progress indication
272 * @param pvUser user defined pointer for the callback
273 */
274RTR3DECL(int) RTSha256Digest(void* pvBuf, size_t cbBuf, char **ppszDigest, PFNRTPROGRESS pfnProgressCallback, void *pvUser);
275
276/**
277 * Creates a SHA256 digest for the given file.
278 *
279 * @returns iprt status code.
280 *
281 * @param pszFile Filename to create a SHA256
282 * digest for.
283 * @param ppszDigest On success the SHA256 digest.
284 * @param pfnProgressCallback optional callback for the progress indication
285 * @param pvUser user defined pointer for the callback
286 */
287RTR3DECL(int) RTSha256DigestFromFile(const char *pszFile, char **ppszDigest, PFNRTPROGRESS pfnProgressCallback, void *pvUser);
288
289
290
291/** The size of a SHA-224 hash. */
292#define RTSHA224_HASH_SIZE 28
293/** The length of a SHA-224 digest string. The terminator is not included. */
294#define RTSHA224_DIGEST_LEN 56
295
296/** SHA-224 context (same as for SHA-256). */
297typedef RTSHA256CONTEXT RTSHA224CONTEXT;
298/** Pointer to an SHA-224 context. */
299typedef RTSHA256CONTEXT *PRTSHA224CONTEXT;
300
301/**
302 * Compute the SHA-224 hash of the data.
303 *
304 * @param pvBuf Pointer to the data.
305 * @param cbBuf The amount of data (in bytes).
306 * @param pabHash Where to store the hash. (What is passed is a pointer to
307 * the caller's buffer.)
308 */
309RTDECL(void) RTSha224(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RTSHA224_HASH_SIZE]);
310
311/**
312 * Computes the SHA-224 hash for the given data comparing it with the one given.
313 *
314 * @returns true on match, false on mismatch.
315 * @param pvBuf Pointer to the data.
316 * @param cbBuf The amount of data (in bytes).
317 * @param pabHash The hash to verify. (What is passed is a pointer to the
318 * caller's buffer.)
319 */
320RTDECL(bool) RTSha224Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA224_HASH_SIZE]);
321
322/**
323 * Initializes the SHA-224 context.
324 *
325 * @param pCtx Pointer to the SHA-224 context.
326 */
327RTDECL(void) RTSha224Init(PRTSHA224CONTEXT pCtx);
328
329/**
330 * Feed data into the SHA-224 computation.
331 *
332 * @param pCtx Pointer to the SHA-224 context.
333 * @param pvBuf Pointer to the data.
334 * @param cbBuf The length of the data (in bytes).
335 */
336RTDECL(void) RTSha224Update(PRTSHA224CONTEXT pCtx, const void *pvBuf, size_t cbBuf);
337
338/**
339 * Compute the SHA-224 hash of the data.
340 *
341 * @param pCtx Pointer to the SHA-224 context.
342 * @param pabHash Where to store the hash. (What is passed is a pointer to
343 * the caller's buffer.)
344 */
345RTDECL(void) RTSha224Final(PRTSHA224CONTEXT pCtx, uint8_t pabHash[RTSHA224_HASH_SIZE]);
346
347/**
348 * Converts a SHA-224 hash to a digest string.
349 *
350 * @returns IPRT status code.
351 *
352 * @param pabHash The binary digest returned by RTSha224Final or RTSha224.
353 * @param pszDigest Where to return the stringified digest.
354 * @param cchDigest The size of the output buffer. Should be at least
355 * RTSHA224_DIGEST_LEN + 1 bytes.
356 */
357RTDECL(int) RTSha224ToString(uint8_t const pabHash[RTSHA224_HASH_SIZE], char *pszDigest, size_t cchDigest);
358
359/**
360 * Converts a SHA-224 hash to a digest string.
361 *
362 * @returns IPRT status code.
363 *
364 * @param pszDigest The stringified digest. Leading and trailing spaces are
365 * ignored.
366 * @param pabHash Where to store the hash. (What is passed is a pointer to
367 * the caller's buffer.)
368 */
369RTDECL(int) RTSha224FromString(char const *pszDigest, uint8_t pabHash[RTSHA224_HASH_SIZE]);
370
371/**
372 * Creates a SHA224 digest for the given memory buffer.
373 *
374 * @returns iprt status code.
375 *
376 * @param pvBuf Memory buffer to create a SHA224 digest for.
377 * @param cbBuf The amount of data (in bytes).
378 * @param ppszDigest On success the SHA224 digest.
379 * @param pfnProgressCallback optional callback for the progress indication
380 * @param pvUser user defined pointer for the callback
381 */
382RTR3DECL(int) RTSha224Digest(void* pvBuf, size_t cbBuf, char **ppszDigest, PFNRTPROGRESS pfnProgressCallback, void *pvUser);
383
384/**
385 * Creates a SHA224 digest for the given file.
386 *
387 * @returns iprt status code.
388 *
389 * @param pszFile Filename to create a SHA224 digest for.
390 * @param ppszDigest On success the SHA224 digest.
391 * @param pfnProgressCallback optional callback for the progress indication
392 * @param pvUser user defined pointer for the callback
393 */
394RTR3DECL(int) RTSha224DigestFromFile(const char *pszFile, char **ppszDigest, PFNRTPROGRESS pfnProgressCallback, void *pvUser);
395
396
397
398/** The size of a SHA-512 hash. */
399#define RTSHA512_HASH_SIZE 64
400/** The length of a SHA-512 digest string. The terminator is not included. */
401#define RTSHA512_DIGEST_LEN 128
402
403/**
404 * SHA-512 context.
405 */
406typedef union RTSHA512CONTEXT
407{
408 uint64_t u64BetterAlignment;
409 uint8_t abPadding[16 + (80 + 8) * 8];
410#ifdef RT_SHA512_PRIVATE_CONTEXT
411 SHA512_CTX Private;
412#endif
413#ifdef RT_SHA512_PRIVATE_ALT_CONTEXT
414 RTSHA512ALTPRIVATECTX AltPrivate;
415#endif
416} RTSHA512CONTEXT;
417/** Pointer to an SHA-512 context. */
418typedef RTSHA512CONTEXT *PRTSHA512CONTEXT;
419
420/**
421 * Compute the SHA-512 hash of the data.
422 *
423 * @param pvBuf Pointer to the data.
424 * @param cbBuf The amount of data (in bytes).
425 * @param pabHash Where to store the hash. (What is passed is a pointer to
426 * the caller's buffer.)
427 */
428RTDECL(void) RTSha512(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RTSHA512_HASH_SIZE]);
429
430/**
431 * Computes the SHA-512 hash for the given data comparing it with the one given.
432 *
433 * @returns true on match, false on mismatch.
434 * @param pvBuf Pointer to the data.
435 * @param cbBuf The amount of data (in bytes).
436 * @param pabHash The hash to verify. (What is passed is a pointer to the
437 * caller's buffer.)
438 */
439RTDECL(bool) RTSha512Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA512_HASH_SIZE]);
440
441/**
442 * Initializes the SHA-512 context.
443 *
444 * @param pCtx Pointer to the SHA-512 context.
445 */
446RTDECL(void) RTSha512Init(PRTSHA512CONTEXT pCtx);
447
448/**
449 * Feed data into the SHA-512 computation.
450 *
451 * @param pCtx Pointer to the SHA-512 context.
452 * @param pvBuf Pointer to the data.
453 * @param cbBuf The length of the data (in bytes).
454 */
455RTDECL(void) RTSha512Update(PRTSHA512CONTEXT pCtx, const void *pvBuf, size_t cbBuf);
456
457/**
458 * Compute the SHA-512 hash of the data.
459 *
460 * @param pCtx Pointer to the SHA-512 context.
461 * @param pabHash Where to store the hash. (What is passed is a pointer to
462 * the caller's buffer.)
463 */
464RTDECL(void) RTSha512Final(PRTSHA512CONTEXT pCtx, uint8_t pabHash[RTSHA512_HASH_SIZE]);
465
466/**
467 * Converts a SHA-512 hash to a digest string.
468 *
469 * @returns IPRT status code.
470 *
471 * @param pabHash The binary digest returned by RTSha512Final or RTSha512.
472 * @param pszDigest Where to return the stringified digest.
473 * @param cchDigest The size of the output buffer. Should be at least
474 * RTSHA512_DIGEST_LEN + 1 bytes.
475 */
476RTDECL(int) RTSha512ToString(uint8_t const pabHash[RTSHA512_HASH_SIZE], char *pszDigest, size_t cchDigest);
477
478/**
479 * Converts a SHA-512 hash to a digest string.
480 *
481 * @returns IPRT status code.
482 *
483 * @param pszDigest The stringified digest. Leading and trailing spaces are
484 * ignored.
485 * @param pabHash Where to store the hash. (What is passed is a pointer to
486 * the caller's buffer.)
487 */
488RTDECL(int) RTSha512FromString(char const *pszDigest, uint8_t pabHash[RTSHA512_HASH_SIZE]);
489
490
491/** Macro for declaring the interface for a SHA-512 variation.
492 * @internal */
493#define RTSHA512_DECLARE_VARIANT(a_Name, a_UName) \
494 typedef RTSHA512CONTEXT RT_CONCAT3(RTSHA,a_UName,CONTEXT); \
495 typedef RTSHA512CONTEXT *RT_CONCAT3(PRTSHA,a_UName,CONTEXT); \
496 RTDECL(void) RT_CONCAT(RTSha,a_Name)(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)]); \
497 RTDECL(bool) RT_CONCAT3(RTSha,a_Name,Check)(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)]); \
498 RTDECL(void) RT_CONCAT3(RTSha,a_Name,Init)(RT_CONCAT3(PRTSHA,a_UName,CONTEXT) pCtx); \
499 RTDECL(void) RT_CONCAT3(RTSha,a_Name,Update)(RT_CONCAT3(PRTSHA,a_UName,CONTEXT) pCtx, const void *pvBuf, size_t cbBuf); \
500 RTDECL(void) RT_CONCAT3(RTSha,a_Name,Final)(RT_CONCAT3(PRTSHA,a_UName,CONTEXT) pCtx, uint8_t pabHash[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)]); \
501 RTDECL(int) RT_CONCAT3(RTSha,a_Name,ToString)(uint8_t const pabHash[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)], char *pszDigest, size_t cchDigest); \
502 RTDECL(int) RT_CONCAT3(RTSha,a_Name,FromString)(char const *pszDigest, uint8_t pabHash[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)])
503
504
505/** The size of a SHA-384 hash. */
506#define RTSHA384_HASH_SIZE 48
507/** The length of a SHA-384 digest string. The terminator is not included. */
508#define RTSHA384_DIGEST_LEN 96
509RTSHA512_DECLARE_VARIANT(384,384);
510
511/** The size of a SHA-512/224 hash. */
512#define RTSHA512T224_HASH_SIZE 28
513/** The length of a SHA-512/224 digest string. The terminator is not
514 * included. */
515#define RTSHA512T224_DIGEST_LEN 56
516RTSHA512_DECLARE_VARIANT(512t224,512T224);
517
518/** The size of a SHA-512/256 hash. */
519#define RTSHA512T256_HASH_SIZE 32
520/** The length of a SHA-512/256 digest string. The terminator is not
521 * included. */
522#define RTSHA512T256_DIGEST_LEN 64
523RTSHA512_DECLARE_VARIANT(512t256,512T256);
524
525
526/**
527 * SHA3 context.
528 */
529typedef union RTSHA3CONTEXT
530{
531 uint64_t a64Padding[26];
532 uint8_t abPadding[208];
533#ifdef RT_SHA3_PRIVATE_CONTEXT
534 RTSHA3PRIVATECTX Private;
535#endif
536#ifdef RT_SHA3_PRIVATE_ALT_CONTEXT
537 RTSHA3ALTPRIVATECTX AltPrivate;
538#endif
539} RTSHA3CONTEXT;
540/** Pointer to an SHA3 context. */
541typedef RTSHA3CONTEXT *PRTSHA3CONTEXT;
542
543/** Macro for declaring the interface for a SHA3 variation.
544 *
545 * @note The interface differes slightly from the older checksums:
546 * - Must call Final and/or Cleanup method.
547 * - Must use Clone instead of memcpy'ing the context.
548 * - Status codes are returned, Init may really fail.
549 *
550 * @internal */
551#define RTSHA3_DECLARE_VARIANT(a_Bits) \
552 typedef struct RT_CONCAT3(RTSHA3T,a_Bits,CONTEXT) { RTSHA3CONTEXT Sha3; } RT_CONCAT3(RTSHA3T,a_Bits,CONTEXT); \
553 typedef RT_CONCAT3(RTSHA3T,a_Bits,CONTEXT) *RT_CONCAT3(PRTSHA3T,a_Bits,CONTEXT); \
554 RTDECL(int) RT_CONCAT(RTSha3t,a_Bits)(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RT_CONCAT3(RTSHA3_,a_Bits,_HASH_SIZE)]); \
555 RTDECL(bool) RT_CONCAT3(RTSha3t,a_Bits,Check)(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RT_CONCAT3(RTSHA3_,a_Bits,_HASH_SIZE)]); \
556 RTDECL(int) RT_CONCAT3(RTSha3t,a_Bits,Init)(RT_CONCAT3(PRTSHA3T,a_Bits,CONTEXT) pCtx); \
557 RTDECL(int) RT_CONCAT3(RTSha3t,a_Bits,Update)(RT_CONCAT3(PRTSHA3T,a_Bits,CONTEXT) pCtx, const void *pvBuf, size_t cbBuf); \
558 RTDECL(int) RT_CONCAT3(RTSha3t,a_Bits,Final)(RT_CONCAT3(PRTSHA3T,a_Bits,CONTEXT) pCtx, uint8_t pabHash[RT_CONCAT3(RTSHA3_,a_Bits,_HASH_SIZE)]); \
559 RTDECL(int) RT_CONCAT3(RTSha3t,a_Bits,Cleanup)(RT_CONCAT3(PRTSHA3T,a_Bits,CONTEXT) pCtx); \
560 RTDECL(int) RT_CONCAT3(RTSha3t,a_Bits,Clone)(RT_CONCAT3(PRTSHA3T,a_Bits,CONTEXT) pCtx, RT_CONCAT3(RTSHA3T,a_Bits,CONTEXT) const *pCtxSrc); \
561 RTDECL(int) RT_CONCAT3(RTSha3t,a_Bits,ToString)(uint8_t const pabHash[RT_CONCAT3(RTSHA3_,a_Bits,_HASH_SIZE)], char *pszDigest, size_t cchDigest); \
562 RTDECL(int) RT_CONCAT3(RTSha3t,a_Bits,FromString)(char const *pszDigest, uint8_t pabHash[RT_CONCAT3(RTSHA3_,a_Bits,_HASH_SIZE)])
563
564/** The size of a SHA-224 hash. */
565#define RTSHA3_224_HASH_SIZE 28
566/** The length of a SHA-224 digest string. The terminator is not included. */
567#define RTSHA3_224_DIGEST_LEN 56
568RTSHA3_DECLARE_VARIANT(224);
569
570/** The size of a SHA-256 hash. */
571#define RTSHA3_256_HASH_SIZE 32
572/** The length of a SHA-256 digest string. The terminator is not included. */
573#define RTSHA3_256_DIGEST_LEN 64
574RTSHA3_DECLARE_VARIANT(256);
575
576/** The size of a SHA-384 hash. */
577#define RTSHA3_384_HASH_SIZE 48
578/** The length of a SHA-384 digest string. The terminator is not included. */
579#define RTSHA3_384_DIGEST_LEN 96
580RTSHA3_DECLARE_VARIANT(384);
581
582/** The size of a SHA-512 hash. */
583#define RTSHA3_512_HASH_SIZE 64
584/** The length of a SHA-512 digest string. The terminator is not included. */
585#define RTSHA3_512_DIGEST_LEN 128
586RTSHA3_DECLARE_VARIANT(512);
587
588/** @} */
589
590RT_C_DECLS_END
591
592#endif /* !IPRT_INCLUDED_sha_h */
593
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use