sha.h@ 98110

Last change on this file since 98110 was 98103, checked in by vboxsync, 23 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
44	RT_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	*/
59	typedef 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. */
71	typedef 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	*/
81	RTDECL(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	*/
92	RTDECL(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	*/
99	RTDECL(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	*/
108	RTDECL(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	*/
117	RTDECL(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	*/
129	RTDECL(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	*/
141	RTDECL(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	*/
154	RTR3DECL(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	*/
166	RTR3DECL(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	*/
178	typedef 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. */
190	typedef 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	*/
200	RTDECL(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	*/
211	RTDECL(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	*/
218	RTDECL(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	*/
227	RTDECL(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	*/
236	RTDECL(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	*/
248	RTDECL(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	*/
260	RTDECL(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	*/
274	RTR3DECL(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	*/
287	RTR3DECL(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). */
297	typedef RTSHA256CONTEXT RTSHA224CONTEXT;
298	/** Pointer to an SHA-224 context. */
299	typedef 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	*/
309	RTDECL(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	*/
320	RTDECL(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	*/
327	RTDECL(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	*/
336	RTDECL(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	*/
345	RTDECL(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	*/
357	RTDECL(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	*/
369	RTDECL(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	*/
382	RTR3DECL(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	*/
394	RTR3DECL(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	*/
406	typedef 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. */
418	typedef 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	*/
428	RTDECL(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	*/
439	RTDECL(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	*/
446	RTDECL(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	*/
455	RTDECL(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	*/
464	RTDECL(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	*/
476	RTDECL(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	*/
488	RTDECL(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
509	RTSHA512_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
516	RTSHA512_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
523	RTSHA512_DECLARE_VARIANT(512t256,512T256);
524
525
526	/**
527	* SHA3 context.
528	*/
529	typedef 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. */
541	typedef 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
568	RTSHA3_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
574	RTSHA3_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
580	RTSHA3_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
586	RTSHA3_DECLARE_VARIANT(512);
587
588	/** @} */
589
590	RT_C_DECLS_END
591
592	#endif /* !IPRT_INCLUDED_sha_h */
593

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: