1 | /* $Id: alt-sha512.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * IPRT - SHA-512 and SHA-384 hash functions, Alternative Implementation.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2009-2019 Oracle Corporation
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
12 | * General Public License (GPL) as published by the Free Software
|
---|
13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | *
|
---|
17 | * The contents of this file may alternatively be used under the terms
|
---|
18 | * of the Common Development and Distribution License Version 1.0
|
---|
19 | * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
|
---|
20 | * VirtualBox OSE distribution, in which case the provisions of the
|
---|
21 | * CDDL are applicable instead of those of the GPL.
|
---|
22 | *
|
---|
23 | * You may elect to license modified versions of this file under the
|
---|
24 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
25 | */
|
---|
26 |
|
---|
27 |
|
---|
28 | /*********************************************************************************************************************************
|
---|
29 | * Defined Constants And Macros *
|
---|
30 | *********************************************************************************************************************************/
|
---|
31 | /** The SHA-512 block size (in bytes). */
|
---|
32 | #define RTSHA512_BLOCK_SIZE 128U
|
---|
33 |
|
---|
34 | /** Enables the unrolled code. */
|
---|
35 | #define RTSHA512_UNROLLED 1
|
---|
36 |
|
---|
37 |
|
---|
38 | /*********************************************************************************************************************************
|
---|
39 | * Header Files *
|
---|
40 | *********************************************************************************************************************************/
|
---|
41 | #include "internal/iprt.h"
|
---|
42 | #include <iprt/types.h>
|
---|
43 | #include <iprt/assert.h>
|
---|
44 | #include <iprt/asm.h>
|
---|
45 | #include <iprt/string.h>
|
---|
46 |
|
---|
47 |
|
---|
48 | /** Our private context structure. */
|
---|
49 | typedef struct RTSHA512ALTPRIVATECTX
|
---|
50 | {
|
---|
51 | /** The W array.
|
---|
52 | * Buffering happens in the first 16 words, converted from big endian to host
|
---|
53 | * endian immediately before processing. The amount of buffered data is kept
|
---|
54 | * in the 6 least significant bits of cbMessage. */
|
---|
55 | uint64_t auW[80];
|
---|
56 | /** The message length (in bytes). */
|
---|
57 | RTUINT128U cbMessage;
|
---|
58 | /** The 8 hash values. */
|
---|
59 | uint64_t auH[8];
|
---|
60 | } RTSHA512ALTPRIVATECTX;
|
---|
61 |
|
---|
62 | #define RT_SHA512_PRIVATE_ALT_CONTEXT
|
---|
63 | #include <iprt/sha.h>
|
---|
64 |
|
---|
65 |
|
---|
66 | AssertCompile(RT_SIZEOFMEMB(RTSHA512CONTEXT, abPadding) >= RT_SIZEOFMEMB(RTSHA512CONTEXT, AltPrivate));
|
---|
67 | AssertCompileMemberSize(RTSHA512ALTPRIVATECTX, auH, RTSHA512_HASH_SIZE);
|
---|
68 |
|
---|
69 |
|
---|
70 | /*********************************************************************************************************************************
|
---|
71 | * Global Variables *
|
---|
72 | *********************************************************************************************************************************/
|
---|
73 | #ifndef RTSHA512_UNROLLED
|
---|
74 | /** The K constants. */
|
---|
75 | static uint64_t const g_auKs[] =
|
---|
76 | {
|
---|
77 | UINT64_C(0x428a2f98d728ae22), UINT64_C(0x7137449123ef65cd), UINT64_C(0xb5c0fbcfec4d3b2f), UINT64_C(0xe9b5dba58189dbbc),
|
---|
78 | UINT64_C(0x3956c25bf348b538), UINT64_C(0x59f111f1b605d019), UINT64_C(0x923f82a4af194f9b), UINT64_C(0xab1c5ed5da6d8118),
|
---|
79 | UINT64_C(0xd807aa98a3030242), UINT64_C(0x12835b0145706fbe), UINT64_C(0x243185be4ee4b28c), UINT64_C(0x550c7dc3d5ffb4e2),
|
---|
80 | UINT64_C(0x72be5d74f27b896f), UINT64_C(0x80deb1fe3b1696b1), UINT64_C(0x9bdc06a725c71235), UINT64_C(0xc19bf174cf692694),
|
---|
81 | UINT64_C(0xe49b69c19ef14ad2), UINT64_C(0xefbe4786384f25e3), UINT64_C(0x0fc19dc68b8cd5b5), UINT64_C(0x240ca1cc77ac9c65),
|
---|
82 | UINT64_C(0x2de92c6f592b0275), UINT64_C(0x4a7484aa6ea6e483), UINT64_C(0x5cb0a9dcbd41fbd4), UINT64_C(0x76f988da831153b5),
|
---|
83 | UINT64_C(0x983e5152ee66dfab), UINT64_C(0xa831c66d2db43210), UINT64_C(0xb00327c898fb213f), UINT64_C(0xbf597fc7beef0ee4),
|
---|
84 | UINT64_C(0xc6e00bf33da88fc2), UINT64_C(0xd5a79147930aa725), UINT64_C(0x06ca6351e003826f), UINT64_C(0x142929670a0e6e70),
|
---|
85 | UINT64_C(0x27b70a8546d22ffc), UINT64_C(0x2e1b21385c26c926), UINT64_C(0x4d2c6dfc5ac42aed), UINT64_C(0x53380d139d95b3df),
|
---|
86 | UINT64_C(0x650a73548baf63de), UINT64_C(0x766a0abb3c77b2a8), UINT64_C(0x81c2c92e47edaee6), UINT64_C(0x92722c851482353b),
|
---|
87 | UINT64_C(0xa2bfe8a14cf10364), UINT64_C(0xa81a664bbc423001), UINT64_C(0xc24b8b70d0f89791), UINT64_C(0xc76c51a30654be30),
|
---|
88 | UINT64_C(0xd192e819d6ef5218), UINT64_C(0xd69906245565a910), UINT64_C(0xf40e35855771202a), UINT64_C(0x106aa07032bbd1b8),
|
---|
89 | UINT64_C(0x19a4c116b8d2d0c8), UINT64_C(0x1e376c085141ab53), UINT64_C(0x2748774cdf8eeb99), UINT64_C(0x34b0bcb5e19b48a8),
|
---|
90 | UINT64_C(0x391c0cb3c5c95a63), UINT64_C(0x4ed8aa4ae3418acb), UINT64_C(0x5b9cca4f7763e373), UINT64_C(0x682e6ff3d6b2b8a3),
|
---|
91 | UINT64_C(0x748f82ee5defb2fc), UINT64_C(0x78a5636f43172f60), UINT64_C(0x84c87814a1f0ab72), UINT64_C(0x8cc702081a6439ec),
|
---|
92 | UINT64_C(0x90befffa23631e28), UINT64_C(0xa4506cebde82bde9), UINT64_C(0xbef9a3f7b2c67915), UINT64_C(0xc67178f2e372532b),
|
---|
93 | UINT64_C(0xca273eceea26619c), UINT64_C(0xd186b8c721c0c207), UINT64_C(0xeada7dd6cde0eb1e), UINT64_C(0xf57d4f7fee6ed178),
|
---|
94 | UINT64_C(0x06f067aa72176fba), UINT64_C(0x0a637dc5a2c898a6), UINT64_C(0x113f9804bef90dae), UINT64_C(0x1b710b35131c471b),
|
---|
95 | UINT64_C(0x28db77f523047d84), UINT64_C(0x32caab7b40c72493), UINT64_C(0x3c9ebe0a15c9bebc), UINT64_C(0x431d67c49c100d4c),
|
---|
96 | UINT64_C(0x4cc5d4becb3e42b6), UINT64_C(0x597f299cfc657e2a), UINT64_C(0x5fcb6fab3ad6faec), UINT64_C(0x6c44198c4a475817),
|
---|
97 | };
|
---|
98 | #endif /* !RTSHA512_UNROLLED */
|
---|
99 |
|
---|
100 |
|
---|
101 |
|
---|
102 | RTDECL(void) RTSha512Init(PRTSHA512CONTEXT pCtx)
|
---|
103 | {
|
---|
104 | pCtx->AltPrivate.cbMessage.s.Lo = 0;
|
---|
105 | pCtx->AltPrivate.cbMessage.s.Hi = 0;
|
---|
106 | pCtx->AltPrivate.auH[0] = UINT64_C(0x6a09e667f3bcc908);
|
---|
107 | pCtx->AltPrivate.auH[1] = UINT64_C(0xbb67ae8584caa73b);
|
---|
108 | pCtx->AltPrivate.auH[2] = UINT64_C(0x3c6ef372fe94f82b);
|
---|
109 | pCtx->AltPrivate.auH[3] = UINT64_C(0xa54ff53a5f1d36f1);
|
---|
110 | pCtx->AltPrivate.auH[4] = UINT64_C(0x510e527fade682d1);
|
---|
111 | pCtx->AltPrivate.auH[5] = UINT64_C(0x9b05688c2b3e6c1f);
|
---|
112 | pCtx->AltPrivate.auH[6] = UINT64_C(0x1f83d9abfb41bd6b);
|
---|
113 | pCtx->AltPrivate.auH[7] = UINT64_C(0x5be0cd19137e2179);
|
---|
114 | }
|
---|
115 | RT_EXPORT_SYMBOL(RTSha512Init);
|
---|
116 |
|
---|
117 |
|
---|
118 | /** Function 4.8. */
|
---|
119 | DECL_FORCE_INLINE(uint64_t) rtSha512Ch(uint64_t uX, uint64_t uY, uint64_t uZ)
|
---|
120 | {
|
---|
121 | #if 1
|
---|
122 | /* Optimization that saves one operation and probably a temporary variable. */
|
---|
123 | uint64_t uResult = uY;
|
---|
124 | uResult ^= uZ;
|
---|
125 | uResult &= uX;
|
---|
126 | uResult ^= uZ;
|
---|
127 | return uResult;
|
---|
128 | #else
|
---|
129 | /* The original. */
|
---|
130 | uint64_t uResult = uX & uY;
|
---|
131 | uResult ^= ~uX & uZ;
|
---|
132 | return uResult;
|
---|
133 | #endif
|
---|
134 | }
|
---|
135 |
|
---|
136 |
|
---|
137 | /** Function 4.9. */
|
---|
138 | DECL_FORCE_INLINE(uint64_t) rtSha512Maj(uint64_t uX, uint64_t uY, uint64_t uZ)
|
---|
139 | {
|
---|
140 | #if 1
|
---|
141 | /* Optimization that save one operation and probably a temporary variable. */
|
---|
142 | uint64_t uResult = uY;
|
---|
143 | uResult ^= uZ;
|
---|
144 | uResult &= uX;
|
---|
145 | uResult ^= uY & uZ;
|
---|
146 | return uResult;
|
---|
147 | #else
|
---|
148 | /* The original. */
|
---|
149 | uint64_t uResult = uX & uY;
|
---|
150 | uResult ^= uX & uZ;
|
---|
151 | uResult ^= uY & uZ;
|
---|
152 | return uResult;
|
---|
153 | #endif
|
---|
154 | }
|
---|
155 |
|
---|
156 |
|
---|
157 | /** Function 4.10. */
|
---|
158 | DECL_FORCE_INLINE(uint64_t) rtSha512CapitalSigma0(uint64_t uX)
|
---|
159 | {
|
---|
160 | uint64_t uResult = uX = ASMRotateRightU64(uX, 28);
|
---|
161 | uX = ASMRotateRightU64(uX, 34 - 28);
|
---|
162 | uResult ^= uX;
|
---|
163 | uX = ASMRotateRightU64(uX, 39 - 34);
|
---|
164 | uResult ^= uX;
|
---|
165 | return uResult;
|
---|
166 | }
|
---|
167 |
|
---|
168 |
|
---|
169 | /** Function 4.11. */
|
---|
170 | DECL_FORCE_INLINE(uint64_t) rtSha512CapitalSigma1(uint64_t uX)
|
---|
171 | {
|
---|
172 | uint64_t uResult = uX = ASMRotateRightU64(uX, 14);
|
---|
173 | uX = ASMRotateRightU64(uX, 18 - 14);
|
---|
174 | uResult ^= uX;
|
---|
175 | uX = ASMRotateRightU64(uX, 41 - 18);
|
---|
176 | uResult ^= uX;
|
---|
177 | return uResult;
|
---|
178 | }
|
---|
179 |
|
---|
180 |
|
---|
181 | /** Function 4.12. */
|
---|
182 | DECL_FORCE_INLINE(uint64_t) rtSha512SmallSigma0(uint64_t uX)
|
---|
183 | {
|
---|
184 | uint64_t uResult = uX >> 7;
|
---|
185 | uX = ASMRotateRightU64(uX, 1);
|
---|
186 | uResult ^= uX;
|
---|
187 | uX = ASMRotateRightU64(uX, 8 - 1);
|
---|
188 | uResult ^= uX;
|
---|
189 | return uResult;
|
---|
190 | }
|
---|
191 |
|
---|
192 |
|
---|
193 | /** Function 4.13. */
|
---|
194 | DECL_FORCE_INLINE(uint64_t) rtSha512SmallSigma1(uint64_t uX)
|
---|
195 | {
|
---|
196 | uint64_t uResult = uX >> 6;
|
---|
197 | uX = ASMRotateRightU64(uX, 19);
|
---|
198 | uResult ^= uX;
|
---|
199 | uX = ASMRotateRightU64(uX, 61 - 19);
|
---|
200 | uResult ^= uX;
|
---|
201 | return uResult;
|
---|
202 | }
|
---|
203 |
|
---|
204 |
|
---|
205 | /**
|
---|
206 | * Initializes the auW array from the specfied input block.
|
---|
207 | *
|
---|
208 | * @param pCtx The SHA-512 context.
|
---|
209 | * @param pbBlock The block. Must be 64-bit aligned.
|
---|
210 | */
|
---|
211 | DECLINLINE(void) rtSha512BlockInit(PRTSHA512CONTEXT pCtx, uint8_t const *pbBlock)
|
---|
212 | {
|
---|
213 | #ifdef RTSHA512_UNROLLED
|
---|
214 | uint64_t const *puSrc = (uint64_t const *)pbBlock;
|
---|
215 | uint64_t *puW = &pCtx->AltPrivate.auW[0];
|
---|
216 | Assert(!((uintptr_t)puSrc & 7));
|
---|
217 | Assert(!((uintptr_t)puW & 7));
|
---|
218 |
|
---|
219 | /* Copy and byte-swap the block. Initializing the rest of the Ws are done
|
---|
220 | in the processing loop. */
|
---|
221 | # ifdef RT_LITTLE_ENDIAN
|
---|
222 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
223 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
224 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
225 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
226 |
|
---|
227 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
228 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
229 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
230 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
231 |
|
---|
232 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
233 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
234 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
235 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
236 |
|
---|
237 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
238 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
239 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
240 | *puW++ = ASMByteSwapU64(*puSrc++);
|
---|
241 | # else
|
---|
242 | memcpy(puW, puSrc, RTSHA512_BLOCK_SIZE);
|
---|
243 | # endif
|
---|
244 |
|
---|
245 | #else /* !RTSHA512_UNROLLED */
|
---|
246 |
|
---|
247 | uint64_t const *pu32Block = (uint64_t const *)pbBlock;
|
---|
248 | Assert(!((uintptr_t)pu32Block & 3));
|
---|
249 |
|
---|
250 | unsigned iWord;
|
---|
251 | for (iWord = 0; iWord < 16; iWord++)
|
---|
252 | pCtx->AltPrivate.auW[iWord] = RT_BE2H_U64(pu32Block[iWord]);
|
---|
253 |
|
---|
254 | for (; iWord < RT_ELEMENTS(pCtx->AltPrivate.auW); iWord++)
|
---|
255 | {
|
---|
256 | uint64_t u64 = rtSha512SmallSigma1(pCtx->AltPrivate.auW[iWord - 2]);
|
---|
257 | u64 += rtSha512SmallSigma0(pCtx->AltPrivate.auW[iWord - 15]);
|
---|
258 | u64 += pCtx->AltPrivate.auW[iWord - 7];
|
---|
259 | u64 += pCtx->AltPrivate.auW[iWord - 16];
|
---|
260 | pCtx->AltPrivate.auW[iWord] = u64;
|
---|
261 | }
|
---|
262 | #endif /* !RTSHA512_UNROLLED */
|
---|
263 | }
|
---|
264 |
|
---|
265 |
|
---|
266 | /**
|
---|
267 | * Initializes the auW array from data buffered in the first part of the array.
|
---|
268 | *
|
---|
269 | * @param pCtx The SHA-512 context.
|
---|
270 | */
|
---|
271 | DECLINLINE(void) rtSha512BlockInitBuffered(PRTSHA512CONTEXT pCtx)
|
---|
272 | {
|
---|
273 | #ifdef RTSHA512_UNROLLED
|
---|
274 | uint64_t *puW = &pCtx->AltPrivate.auW[0];
|
---|
275 | Assert(!((uintptr_t)puW & 7));
|
---|
276 |
|
---|
277 | /* Do the byte swap if necessary. Initializing the rest of the Ws are done
|
---|
278 | in the processing loop. */
|
---|
279 | # ifdef RT_LITTLE_ENDIAN
|
---|
280 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
281 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
282 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
283 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
284 |
|
---|
285 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
286 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
287 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
288 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
289 |
|
---|
290 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
291 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
292 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
293 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
294 |
|
---|
295 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
296 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
297 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
298 | *puW = ASMByteSwapU64(*puW); puW++;
|
---|
299 | # endif
|
---|
300 |
|
---|
301 | #else /* !RTSHA512_UNROLLED */
|
---|
302 |
|
---|
303 | unsigned iWord;
|
---|
304 | for (iWord = 0; iWord < 16; iWord++)
|
---|
305 | pCtx->AltPrivate.auW[iWord] = RT_BE2H_U64(pCtx->AltPrivate.auW[iWord]);
|
---|
306 |
|
---|
307 | for (; iWord < RT_ELEMENTS(pCtx->AltPrivate.auW); iWord++)
|
---|
308 | {
|
---|
309 | uint64_t u64 = rtSha512SmallSigma1(pCtx->AltPrivate.auW[iWord - 2]);
|
---|
310 | u64 += rtSha512SmallSigma0(pCtx->AltPrivate.auW[iWord - 15]);
|
---|
311 | u64 += pCtx->AltPrivate.auW[iWord - 7];
|
---|
312 | u64 += pCtx->AltPrivate.auW[iWord - 16];
|
---|
313 | pCtx->AltPrivate.auW[iWord] = u64;
|
---|
314 | }
|
---|
315 | #endif /* !RTSHA512_UNROLLED */
|
---|
316 | }
|
---|
317 |
|
---|
318 |
|
---|
319 | /**
|
---|
320 | * Process the current block.
|
---|
321 | *
|
---|
322 | * Requires one of the rtSha512BlockInit functions to be called first.
|
---|
323 | *
|
---|
324 | * @param pCtx The SHA-512 context.
|
---|
325 | */
|
---|
326 | static void rtSha512BlockProcess(PRTSHA512CONTEXT pCtx)
|
---|
327 | {
|
---|
328 | uint64_t uA = pCtx->AltPrivate.auH[0];
|
---|
329 | uint64_t uB = pCtx->AltPrivate.auH[1];
|
---|
330 | uint64_t uC = pCtx->AltPrivate.auH[2];
|
---|
331 | uint64_t uD = pCtx->AltPrivate.auH[3];
|
---|
332 | uint64_t uE = pCtx->AltPrivate.auH[4];
|
---|
333 | uint64_t uF = pCtx->AltPrivate.auH[5];
|
---|
334 | uint64_t uG = pCtx->AltPrivate.auH[6];
|
---|
335 | uint64_t uH = pCtx->AltPrivate.auH[7];
|
---|
336 |
|
---|
337 | #ifdef RTSHA512_UNROLLED
|
---|
338 | uint64_t *puW = &pCtx->AltPrivate.auW[0];
|
---|
339 | # define RTSHA512_BODY(a_iWord, a_uK, a_uA, a_uB, a_uC, a_uD, a_uE, a_uF, a_uG, a_uH) \
|
---|
340 | do { \
|
---|
341 | if ((a_iWord) < 16) \
|
---|
342 | a_uH += *puW++; \
|
---|
343 | else \
|
---|
344 | { \
|
---|
345 | uint64_t u64 = puW[-16]; \
|
---|
346 | u64 += rtSha512SmallSigma0(puW[-15]); \
|
---|
347 | u64 += puW[-7]; \
|
---|
348 | u64 += rtSha512SmallSigma1(puW[-2]); \
|
---|
349 | if (a_iWord < 80-2) *puW++ = u64; else puW++; \
|
---|
350 | a_uH += u64; \
|
---|
351 | } \
|
---|
352 | \
|
---|
353 | a_uH += rtSha512CapitalSigma1(a_uE); \
|
---|
354 | a_uH += a_uK; \
|
---|
355 | a_uH += rtSha512Ch(a_uE, a_uF, a_uG); \
|
---|
356 | a_uD += a_uH; \
|
---|
357 | \
|
---|
358 | a_uH += rtSha512CapitalSigma0(a_uA); \
|
---|
359 | a_uH += rtSha512Maj(a_uA, a_uB, a_uC); \
|
---|
360 | } while (0)
|
---|
361 | # define RTSHA512_EIGHT(a_uK0, a_uK1, a_uK2, a_uK3, a_uK4, a_uK5, a_uK6, a_uK7, a_iFirst) \
|
---|
362 | do { \
|
---|
363 | RTSHA512_BODY(a_iFirst + 0, a_uK0, uA, uB, uC, uD, uE, uF, uG, uH); \
|
---|
364 | RTSHA512_BODY(a_iFirst + 1, a_uK1, uH, uA, uB, uC, uD, uE, uF, uG); \
|
---|
365 | RTSHA512_BODY(a_iFirst + 2, a_uK2, uG, uH, uA, uB, uC, uD, uE, uF); \
|
---|
366 | RTSHA512_BODY(a_iFirst + 3, a_uK3, uF, uG, uH, uA, uB, uC, uD, uE); \
|
---|
367 | RTSHA512_BODY(a_iFirst + 4, a_uK4, uE, uF, uG, uH, uA, uB, uC, uD); \
|
---|
368 | RTSHA512_BODY(a_iFirst + 5, a_uK5, uD, uE, uF, uG, uH, uA, uB, uC); \
|
---|
369 | RTSHA512_BODY(a_iFirst + 6, a_uK6, uC, uD, uE, uF, uG, uH, uA, uB); \
|
---|
370 | RTSHA512_BODY(a_iFirst + 7, a_uK7, uB, uC, uD, uE, uF, uG, uH, uA); \
|
---|
371 | } while (0)
|
---|
372 | RTSHA512_EIGHT(UINT64_C(0x428a2f98d728ae22), UINT64_C(0x7137449123ef65cd), UINT64_C(0xb5c0fbcfec4d3b2f), UINT64_C(0xe9b5dba58189dbbc),
|
---|
373 | UINT64_C(0x3956c25bf348b538), UINT64_C(0x59f111f1b605d019), UINT64_C(0x923f82a4af194f9b), UINT64_C(0xab1c5ed5da6d8118),
|
---|
374 | 0);
|
---|
375 | RTSHA512_EIGHT(UINT64_C(0xd807aa98a3030242), UINT64_C(0x12835b0145706fbe), UINT64_C(0x243185be4ee4b28c), UINT64_C(0x550c7dc3d5ffb4e2),
|
---|
376 | UINT64_C(0x72be5d74f27b896f), UINT64_C(0x80deb1fe3b1696b1), UINT64_C(0x9bdc06a725c71235), UINT64_C(0xc19bf174cf692694),
|
---|
377 | 8);
|
---|
378 | RTSHA512_EIGHT(UINT64_C(0xe49b69c19ef14ad2), UINT64_C(0xefbe4786384f25e3), UINT64_C(0x0fc19dc68b8cd5b5), UINT64_C(0x240ca1cc77ac9c65),
|
---|
379 | UINT64_C(0x2de92c6f592b0275), UINT64_C(0x4a7484aa6ea6e483), UINT64_C(0x5cb0a9dcbd41fbd4), UINT64_C(0x76f988da831153b5),
|
---|
380 | 16);
|
---|
381 | RTSHA512_EIGHT(UINT64_C(0x983e5152ee66dfab), UINT64_C(0xa831c66d2db43210), UINT64_C(0xb00327c898fb213f), UINT64_C(0xbf597fc7beef0ee4),
|
---|
382 | UINT64_C(0xc6e00bf33da88fc2), UINT64_C(0xd5a79147930aa725), UINT64_C(0x06ca6351e003826f), UINT64_C(0x142929670a0e6e70),
|
---|
383 | 24);
|
---|
384 | RTSHA512_EIGHT(UINT64_C(0x27b70a8546d22ffc), UINT64_C(0x2e1b21385c26c926), UINT64_C(0x4d2c6dfc5ac42aed), UINT64_C(0x53380d139d95b3df),
|
---|
385 | UINT64_C(0x650a73548baf63de), UINT64_C(0x766a0abb3c77b2a8), UINT64_C(0x81c2c92e47edaee6), UINT64_C(0x92722c851482353b),
|
---|
386 | 32);
|
---|
387 | RTSHA512_EIGHT(UINT64_C(0xa2bfe8a14cf10364), UINT64_C(0xa81a664bbc423001), UINT64_C(0xc24b8b70d0f89791), UINT64_C(0xc76c51a30654be30),
|
---|
388 | UINT64_C(0xd192e819d6ef5218), UINT64_C(0xd69906245565a910), UINT64_C(0xf40e35855771202a), UINT64_C(0x106aa07032bbd1b8),
|
---|
389 | 40);
|
---|
390 | RTSHA512_EIGHT(UINT64_C(0x19a4c116b8d2d0c8), UINT64_C(0x1e376c085141ab53), UINT64_C(0x2748774cdf8eeb99), UINT64_C(0x34b0bcb5e19b48a8),
|
---|
391 | UINT64_C(0x391c0cb3c5c95a63), UINT64_C(0x4ed8aa4ae3418acb), UINT64_C(0x5b9cca4f7763e373), UINT64_C(0x682e6ff3d6b2b8a3),
|
---|
392 | 48);
|
---|
393 | RTSHA512_EIGHT(UINT64_C(0x748f82ee5defb2fc), UINT64_C(0x78a5636f43172f60), UINT64_C(0x84c87814a1f0ab72), UINT64_C(0x8cc702081a6439ec),
|
---|
394 | UINT64_C(0x90befffa23631e28), UINT64_C(0xa4506cebde82bde9), UINT64_C(0xbef9a3f7b2c67915), UINT64_C(0xc67178f2e372532b),
|
---|
395 | 56);
|
---|
396 | RTSHA512_EIGHT(UINT64_C(0xca273eceea26619c), UINT64_C(0xd186b8c721c0c207), UINT64_C(0xeada7dd6cde0eb1e), UINT64_C(0xf57d4f7fee6ed178),
|
---|
397 | UINT64_C(0x06f067aa72176fba), UINT64_C(0x0a637dc5a2c898a6), UINT64_C(0x113f9804bef90dae), UINT64_C(0x1b710b35131c471b),
|
---|
398 | 64);
|
---|
399 | RTSHA512_EIGHT(UINT64_C(0x28db77f523047d84), UINT64_C(0x32caab7b40c72493), UINT64_C(0x3c9ebe0a15c9bebc), UINT64_C(0x431d67c49c100d4c),
|
---|
400 | UINT64_C(0x4cc5d4becb3e42b6), UINT64_C(0x597f299cfc657e2a), UINT64_C(0x5fcb6fab3ad6faec), UINT64_C(0x6c44198c4a475817),
|
---|
401 | 72);
|
---|
402 | #else
|
---|
403 | for (unsigned iWord = 0; iWord < RT_ELEMENTS(pCtx->AltPrivate.auW); iWord++)
|
---|
404 | {
|
---|
405 | uint64_t uT1 = uH;
|
---|
406 | uT1 += rtSha512CapitalSigma1(uE);
|
---|
407 | uT1 += rtSha512Ch(uE, uF, uG);
|
---|
408 | uT1 += g_auKs[iWord];
|
---|
409 | uT1 += pCtx->AltPrivate.auW[iWord];
|
---|
410 |
|
---|
411 | uint64_t uT2 = rtSha512CapitalSigma0(uA);
|
---|
412 | uT2 += rtSha512Maj(uA, uB, uC);
|
---|
413 |
|
---|
414 | uH = uG;
|
---|
415 | uG = uF;
|
---|
416 | uF = uE;
|
---|
417 | uE = uD + uT1;
|
---|
418 | uD = uC;
|
---|
419 | uC = uB;
|
---|
420 | uB = uA;
|
---|
421 | uA = uT1 + uT2;
|
---|
422 | }
|
---|
423 | #endif
|
---|
424 |
|
---|
425 | pCtx->AltPrivate.auH[0] += uA;
|
---|
426 | pCtx->AltPrivate.auH[1] += uB;
|
---|
427 | pCtx->AltPrivate.auH[2] += uC;
|
---|
428 | pCtx->AltPrivate.auH[3] += uD;
|
---|
429 | pCtx->AltPrivate.auH[4] += uE;
|
---|
430 | pCtx->AltPrivate.auH[5] += uF;
|
---|
431 | pCtx->AltPrivate.auH[6] += uG;
|
---|
432 | pCtx->AltPrivate.auH[7] += uH;
|
---|
433 | }
|
---|
434 |
|
---|
435 |
|
---|
436 | RTDECL(void) RTSha512Update(PRTSHA512CONTEXT pCtx, const void *pvBuf, size_t cbBuf)
|
---|
437 | {
|
---|
438 | Assert(pCtx->AltPrivate.cbMessage.s.Hi < UINT64_MAX / 8);
|
---|
439 | uint8_t const *pbBuf = (uint8_t const *)pvBuf;
|
---|
440 |
|
---|
441 | /*
|
---|
442 | * Deal with buffered bytes first.
|
---|
443 | */
|
---|
444 | size_t cbBuffered = (size_t)pCtx->AltPrivate.cbMessage.s.Lo & (RTSHA512_BLOCK_SIZE - 1U);
|
---|
445 | if (cbBuffered)
|
---|
446 | {
|
---|
447 | size_t cbMissing = RTSHA512_BLOCK_SIZE - cbBuffered;
|
---|
448 | if (cbBuf >= cbMissing)
|
---|
449 | {
|
---|
450 | memcpy((uint8_t *)&pCtx->AltPrivate.auW[0] + cbBuffered, pbBuf, cbMissing);
|
---|
451 | pCtx->AltPrivate.cbMessage.s.Lo += cbMissing;
|
---|
452 | if (!pCtx->AltPrivate.cbMessage.s.Lo)
|
---|
453 | pCtx->AltPrivate.cbMessage.s.Hi++;
|
---|
454 | pbBuf += cbMissing;
|
---|
455 | cbBuf -= cbMissing;
|
---|
456 |
|
---|
457 | rtSha512BlockInitBuffered(pCtx);
|
---|
458 | rtSha512BlockProcess(pCtx);
|
---|
459 | }
|
---|
460 | else
|
---|
461 | {
|
---|
462 | memcpy((uint8_t *)&pCtx->AltPrivate.auW[0] + cbBuffered, pbBuf, cbBuf);
|
---|
463 | pCtx->AltPrivate.cbMessage.s.Lo += cbBuf;
|
---|
464 | return;
|
---|
465 | }
|
---|
466 | }
|
---|
467 |
|
---|
468 | if (!((uintptr_t)pbBuf & 7))
|
---|
469 | {
|
---|
470 | /*
|
---|
471 | * Process full blocks directly from the input buffer.
|
---|
472 | */
|
---|
473 | while (cbBuf >= RTSHA512_BLOCK_SIZE)
|
---|
474 | {
|
---|
475 | rtSha512BlockInit(pCtx, pbBuf);
|
---|
476 | rtSha512BlockProcess(pCtx);
|
---|
477 |
|
---|
478 | pCtx->AltPrivate.cbMessage.s.Lo += RTSHA512_BLOCK_SIZE;
|
---|
479 | if (!pCtx->AltPrivate.cbMessage.s.Lo)
|
---|
480 | pCtx->AltPrivate.cbMessage.s.Hi++;
|
---|
481 | pbBuf += RTSHA512_BLOCK_SIZE;
|
---|
482 | cbBuf -= RTSHA512_BLOCK_SIZE;
|
---|
483 | }
|
---|
484 | }
|
---|
485 | else
|
---|
486 | {
|
---|
487 | /*
|
---|
488 | * Unaligned input, so buffer it.
|
---|
489 | */
|
---|
490 | while (cbBuf >= RTSHA512_BLOCK_SIZE)
|
---|
491 | {
|
---|
492 | memcpy((uint8_t *)&pCtx->AltPrivate.auW[0], pbBuf, RTSHA512_BLOCK_SIZE);
|
---|
493 | rtSha512BlockInitBuffered(pCtx);
|
---|
494 | rtSha512BlockProcess(pCtx);
|
---|
495 |
|
---|
496 | pCtx->AltPrivate.cbMessage.s.Lo += RTSHA512_BLOCK_SIZE;
|
---|
497 | if (!pCtx->AltPrivate.cbMessage.s.Lo)
|
---|
498 | pCtx->AltPrivate.cbMessage.s.Hi++;
|
---|
499 | pbBuf += RTSHA512_BLOCK_SIZE;
|
---|
500 | cbBuf -= RTSHA512_BLOCK_SIZE;
|
---|
501 | }
|
---|
502 | }
|
---|
503 |
|
---|
504 | /*
|
---|
505 | * Stash any remaining bytes into the context buffer.
|
---|
506 | */
|
---|
507 | if (cbBuf > 0)
|
---|
508 | {
|
---|
509 | memcpy((uint8_t *)&pCtx->AltPrivate.auW[0], pbBuf, cbBuf);
|
---|
510 | pCtx->AltPrivate.cbMessage.s.Lo += cbBuf;
|
---|
511 | if (!pCtx->AltPrivate.cbMessage.s.Lo)
|
---|
512 | pCtx->AltPrivate.cbMessage.s.Hi++;
|
---|
513 | }
|
---|
514 | }
|
---|
515 | RT_EXPORT_SYMBOL(RTSha512Update);
|
---|
516 |
|
---|
517 |
|
---|
518 | /**
|
---|
519 | * Internal worker for RTSha512Final and RTSha384Final that finalizes the
|
---|
520 | * computation but does not copy out the hash value.
|
---|
521 | *
|
---|
522 | * @param pCtx The SHA-512 context.
|
---|
523 | */
|
---|
524 | static void rtSha512FinalInternal(PRTSHA512CONTEXT pCtx)
|
---|
525 | {
|
---|
526 | Assert(pCtx->AltPrivate.cbMessage.s.Hi < UINT64_MAX / 8);
|
---|
527 |
|
---|
528 | /*
|
---|
529 | * Complete the message by adding a single bit (0x80), padding till
|
---|
530 | * the next 448-bit boundrary, the add the message length.
|
---|
531 | */
|
---|
532 | RTUINT128U cMessageBits = pCtx->AltPrivate.cbMessage;
|
---|
533 | cMessageBits.s.Hi <<= 3;
|
---|
534 | cMessageBits.s.Hi |= cMessageBits.s.Lo >> 61;
|
---|
535 | cMessageBits.s.Lo <<= 3;
|
---|
536 |
|
---|
537 | unsigned cbMissing = RTSHA512_BLOCK_SIZE - ((unsigned)pCtx->AltPrivate.cbMessage.s.Lo & (RTSHA512_BLOCK_SIZE - 1U));
|
---|
538 | static uint8_t const s_abSingleBitAndSomePadding[20] =
|
---|
539 | { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
|
---|
540 | if (cbMissing < 1U + 16U)
|
---|
541 | /* Less than 64+16 bits left in the current block, force a new block. */
|
---|
542 | RTSha512Update(pCtx, &s_abSingleBitAndSomePadding, sizeof(s_abSingleBitAndSomePadding));
|
---|
543 | else
|
---|
544 | RTSha512Update(pCtx, &s_abSingleBitAndSomePadding, 1);
|
---|
545 |
|
---|
546 | unsigned cbBuffered = (unsigned)pCtx->AltPrivate.cbMessage.s.Lo & (RTSHA512_BLOCK_SIZE - 1U);
|
---|
547 | cbMissing = RTSHA512_BLOCK_SIZE - cbBuffered;
|
---|
548 | Assert(cbMissing >= 16);
|
---|
549 | memset((uint8_t *)&pCtx->AltPrivate.auW[0] + cbBuffered, 0, cbMissing - 16);
|
---|
550 |
|
---|
551 | pCtx->AltPrivate.auW[14] = RT_H2BE_U64(cMessageBits.s.Hi);
|
---|
552 | pCtx->AltPrivate.auW[15] = RT_H2BE_U64(cMessageBits.s.Lo);
|
---|
553 |
|
---|
554 | /*
|
---|
555 | * Process the last buffered block constructed/completed above.
|
---|
556 | */
|
---|
557 | rtSha512BlockInitBuffered(pCtx);
|
---|
558 | rtSha512BlockProcess(pCtx);
|
---|
559 |
|
---|
560 | /*
|
---|
561 | * Convert the byte order of the hash words and we're done.
|
---|
562 | */
|
---|
563 | pCtx->AltPrivate.auH[0] = RT_H2BE_U64(pCtx->AltPrivate.auH[0]);
|
---|
564 | pCtx->AltPrivate.auH[1] = RT_H2BE_U64(pCtx->AltPrivate.auH[1]);
|
---|
565 | pCtx->AltPrivate.auH[2] = RT_H2BE_U64(pCtx->AltPrivate.auH[2]);
|
---|
566 | pCtx->AltPrivate.auH[3] = RT_H2BE_U64(pCtx->AltPrivate.auH[3]);
|
---|
567 | pCtx->AltPrivate.auH[4] = RT_H2BE_U64(pCtx->AltPrivate.auH[4]);
|
---|
568 | pCtx->AltPrivate.auH[5] = RT_H2BE_U64(pCtx->AltPrivate.auH[5]);
|
---|
569 | pCtx->AltPrivate.auH[6] = RT_H2BE_U64(pCtx->AltPrivate.auH[6]);
|
---|
570 | pCtx->AltPrivate.auH[7] = RT_H2BE_U64(pCtx->AltPrivate.auH[7]);
|
---|
571 |
|
---|
572 | RT_ZERO(pCtx->AltPrivate.auW);
|
---|
573 | pCtx->AltPrivate.cbMessage.s.Lo = UINT64_MAX;
|
---|
574 | pCtx->AltPrivate.cbMessage.s.Hi = UINT64_MAX;
|
---|
575 | }
|
---|
576 | RT_EXPORT_SYMBOL(RTSha512Final);
|
---|
577 |
|
---|
578 |
|
---|
579 | RTDECL(void) RTSha512Final(PRTSHA512CONTEXT pCtx, uint8_t pabDigest[RTSHA512_HASH_SIZE])
|
---|
580 | {
|
---|
581 | rtSha512FinalInternal(pCtx);
|
---|
582 | memcpy(pabDigest, &pCtx->AltPrivate.auH[0], RTSHA512_HASH_SIZE);
|
---|
583 | RT_ZERO(pCtx->AltPrivate.auH);
|
---|
584 | }
|
---|
585 | RT_EXPORT_SYMBOL(RTSha512Final);
|
---|
586 |
|
---|
587 |
|
---|
588 | RTDECL(void) RTSha512(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA512_HASH_SIZE])
|
---|
589 | {
|
---|
590 | RTSHA512CONTEXT Ctx;
|
---|
591 | RTSha512Init(&Ctx);
|
---|
592 | RTSha512Update(&Ctx, pvBuf, cbBuf);
|
---|
593 | RTSha512Final(&Ctx, pabDigest);
|
---|
594 | }
|
---|
595 | RT_EXPORT_SYMBOL(RTSha512);
|
---|
596 |
|
---|
597 |
|
---|
598 | RTDECL(bool) RTSha512Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA512_HASH_SIZE])
|
---|
599 | {
|
---|
600 | RTSHA512CONTEXT Ctx;
|
---|
601 | RTSha512Init(&Ctx);
|
---|
602 | RTSha512Update(&Ctx, pvBuf, cbBuf);
|
---|
603 | rtSha512FinalInternal(&Ctx);
|
---|
604 |
|
---|
605 | bool fRet = memcmp(pabHash, &Ctx.AltPrivate.auH[0], RTSHA512_HASH_SIZE) == 0;
|
---|
606 |
|
---|
607 | RT_ZERO(Ctx.AltPrivate.auH);
|
---|
608 | return fRet;
|
---|
609 | }
|
---|
610 | RT_EXPORT_SYMBOL(RTSha512Check);
|
---|
611 |
|
---|
612 |
|
---|
613 |
|
---|
614 | /*
|
---|
615 | * SHA-384 is just SHA-512 with different initial values an a truncated result.
|
---|
616 | */
|
---|
617 |
|
---|
618 | RTDECL(void) RTSha384Init(PRTSHA384CONTEXT pCtx)
|
---|
619 | {
|
---|
620 | pCtx->AltPrivate.cbMessage.s.Lo = 0;
|
---|
621 | pCtx->AltPrivate.cbMessage.s.Hi = 0;
|
---|
622 | pCtx->AltPrivate.auH[0] = UINT64_C(0xcbbb9d5dc1059ed8);
|
---|
623 | pCtx->AltPrivate.auH[1] = UINT64_C(0x629a292a367cd507);
|
---|
624 | pCtx->AltPrivate.auH[2] = UINT64_C(0x9159015a3070dd17);
|
---|
625 | pCtx->AltPrivate.auH[3] = UINT64_C(0x152fecd8f70e5939);
|
---|
626 | pCtx->AltPrivate.auH[4] = UINT64_C(0x67332667ffc00b31);
|
---|
627 | pCtx->AltPrivate.auH[5] = UINT64_C(0x8eb44a8768581511);
|
---|
628 | pCtx->AltPrivate.auH[6] = UINT64_C(0xdb0c2e0d64f98fa7);
|
---|
629 | pCtx->AltPrivate.auH[7] = UINT64_C(0x47b5481dbefa4fa4);
|
---|
630 | }
|
---|
631 | RT_EXPORT_SYMBOL(RTSha384Init);
|
---|
632 |
|
---|
633 |
|
---|
634 | RTDECL(void) RTSha384Update(PRTSHA384CONTEXT pCtx, const void *pvBuf, size_t cbBuf)
|
---|
635 | {
|
---|
636 | RTSha512Update(pCtx, pvBuf, cbBuf);
|
---|
637 | }
|
---|
638 | RT_EXPORT_SYMBOL(RTSha384Update);
|
---|
639 |
|
---|
640 |
|
---|
641 | RTDECL(void) RTSha384Final(PRTSHA384CONTEXT pCtx, uint8_t pabDigest[RTSHA384_HASH_SIZE])
|
---|
642 | {
|
---|
643 | rtSha512FinalInternal(pCtx);
|
---|
644 | memcpy(pabDigest, &pCtx->AltPrivate.auH[0], RTSHA384_HASH_SIZE);
|
---|
645 | RT_ZERO(pCtx->AltPrivate.auH);
|
---|
646 | }
|
---|
647 | RT_EXPORT_SYMBOL(RTSha384Final);
|
---|
648 |
|
---|
649 |
|
---|
650 | RTDECL(void) RTSha384(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA384_HASH_SIZE])
|
---|
651 | {
|
---|
652 | RTSHA384CONTEXT Ctx;
|
---|
653 | RTSha384Init(&Ctx);
|
---|
654 | RTSha384Update(&Ctx, pvBuf, cbBuf);
|
---|
655 | RTSha384Final(&Ctx, pabDigest);
|
---|
656 | }
|
---|
657 | RT_EXPORT_SYMBOL(RTSha384);
|
---|
658 |
|
---|
659 |
|
---|
660 | RTDECL(bool) RTSha384Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA384_HASH_SIZE])
|
---|
661 | {
|
---|
662 | RTSHA384CONTEXT Ctx;
|
---|
663 | RTSha384Init(&Ctx);
|
---|
664 | RTSha384Update(&Ctx, pvBuf, cbBuf);
|
---|
665 | rtSha512FinalInternal(&Ctx);
|
---|
666 |
|
---|
667 | bool fRet = memcmp(pabHash, &Ctx.AltPrivate.auH[0], RTSHA384_HASH_SIZE) == 0;
|
---|
668 |
|
---|
669 | RT_ZERO(Ctx.AltPrivate.auH);
|
---|
670 | return fRet;
|
---|
671 | }
|
---|
672 | RT_EXPORT_SYMBOL(RTSha384Check);
|
---|
673 |
|
---|
674 |
|
---|
675 | /*
|
---|
676 | * SHA-512/224 is just SHA-512 with different initial values an a truncated result.
|
---|
677 | */
|
---|
678 |
|
---|
679 | RTDECL(void) RTSha512t224Init(PRTSHA512T224CONTEXT pCtx)
|
---|
680 | {
|
---|
681 | pCtx->AltPrivate.cbMessage.s.Lo = 0;
|
---|
682 | pCtx->AltPrivate.cbMessage.s.Hi = 0;
|
---|
683 | pCtx->AltPrivate.auH[0] = UINT64_C(0x8c3d37c819544da2);
|
---|
684 | pCtx->AltPrivate.auH[1] = UINT64_C(0x73e1996689dcd4d6);
|
---|
685 | pCtx->AltPrivate.auH[2] = UINT64_C(0x1dfab7ae32ff9c82);
|
---|
686 | pCtx->AltPrivate.auH[3] = UINT64_C(0x679dd514582f9fcf);
|
---|
687 | pCtx->AltPrivate.auH[4] = UINT64_C(0x0f6d2b697bd44da8);
|
---|
688 | pCtx->AltPrivate.auH[5] = UINT64_C(0x77e36f7304c48942);
|
---|
689 | pCtx->AltPrivate.auH[6] = UINT64_C(0x3f9d85a86a1d36c8);
|
---|
690 | pCtx->AltPrivate.auH[7] = UINT64_C(0x1112e6ad91d692a1);
|
---|
691 | }
|
---|
692 | RT_EXPORT_SYMBOL(RTSha512t224Init);
|
---|
693 |
|
---|
694 |
|
---|
695 | RTDECL(void) RTSha512t224Update(PRTSHA512T224CONTEXT pCtx, const void *pvBuf, size_t cbBuf)
|
---|
696 | {
|
---|
697 | RTSha512Update(pCtx, pvBuf, cbBuf);
|
---|
698 | }
|
---|
699 | RT_EXPORT_SYMBOL(RTSha512t224Update);
|
---|
700 |
|
---|
701 |
|
---|
702 | RTDECL(void) RTSha512t224Final(PRTSHA512T224CONTEXT pCtx, uint8_t pabDigest[RTSHA512T224_HASH_SIZE])
|
---|
703 | {
|
---|
704 | rtSha512FinalInternal(pCtx);
|
---|
705 | memcpy(pabDigest, &pCtx->AltPrivate.auH[0], RTSHA512T224_HASH_SIZE);
|
---|
706 | RT_ZERO(pCtx->AltPrivate.auH);
|
---|
707 | }
|
---|
708 | RT_EXPORT_SYMBOL(RTSha512t224Final);
|
---|
709 |
|
---|
710 |
|
---|
711 | RTDECL(void) RTSha512t224(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA512T224_HASH_SIZE])
|
---|
712 | {
|
---|
713 | RTSHA512T224CONTEXT Ctx;
|
---|
714 | RTSha512t224Init(&Ctx);
|
---|
715 | RTSha512t224Update(&Ctx, pvBuf, cbBuf);
|
---|
716 | RTSha512t224Final(&Ctx, pabDigest);
|
---|
717 | }
|
---|
718 | RT_EXPORT_SYMBOL(RTSha512t224);
|
---|
719 |
|
---|
720 |
|
---|
721 | RTDECL(bool) RTSha512t224Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA512T224_HASH_SIZE])
|
---|
722 | {
|
---|
723 | RTSHA512T224CONTEXT Ctx;
|
---|
724 | RTSha512t224Init(&Ctx);
|
---|
725 | RTSha512t224Update(&Ctx, pvBuf, cbBuf);
|
---|
726 | rtSha512FinalInternal(&Ctx);
|
---|
727 |
|
---|
728 | bool fRet = memcmp(pabHash, &Ctx.AltPrivate.auH[0], RTSHA512T224_HASH_SIZE) == 0;
|
---|
729 |
|
---|
730 | RT_ZERO(Ctx.AltPrivate.auH);
|
---|
731 | return fRet;
|
---|
732 | }
|
---|
733 | RT_EXPORT_SYMBOL(RTSha512t224Check);
|
---|
734 |
|
---|
735 |
|
---|
736 | /*
|
---|
737 | * SHA-512/256 is just SHA-512 with different initial values an a truncated result.
|
---|
738 | */
|
---|
739 |
|
---|
740 | RTDECL(void) RTSha512t256Init(PRTSHA512T256CONTEXT pCtx)
|
---|
741 | {
|
---|
742 | pCtx->AltPrivate.cbMessage.s.Lo = 0;
|
---|
743 | pCtx->AltPrivate.cbMessage.s.Hi = 0;
|
---|
744 | pCtx->AltPrivate.auH[0] = UINT64_C(0x22312194fc2bf72c);
|
---|
745 | pCtx->AltPrivate.auH[1] = UINT64_C(0x9f555fa3c84c64c2);
|
---|
746 | pCtx->AltPrivate.auH[2] = UINT64_C(0x2393b86b6f53b151);
|
---|
747 | pCtx->AltPrivate.auH[3] = UINT64_C(0x963877195940eabd);
|
---|
748 | pCtx->AltPrivate.auH[4] = UINT64_C(0x96283ee2a88effe3);
|
---|
749 | pCtx->AltPrivate.auH[5] = UINT64_C(0xbe5e1e2553863992);
|
---|
750 | pCtx->AltPrivate.auH[6] = UINT64_C(0x2b0199fc2c85b8aa);
|
---|
751 | pCtx->AltPrivate.auH[7] = UINT64_C(0x0eb72ddc81c52ca2);
|
---|
752 | }
|
---|
753 | RT_EXPORT_SYMBOL(RTSha512t256Init);
|
---|
754 |
|
---|
755 |
|
---|
756 | RTDECL(void) RTSha512t256Update(PRTSHA512T256CONTEXT pCtx, const void *pvBuf, size_t cbBuf)
|
---|
757 | {
|
---|
758 | RTSha512Update(pCtx, pvBuf, cbBuf);
|
---|
759 | }
|
---|
760 | RT_EXPORT_SYMBOL(RTSha512t256Update);
|
---|
761 |
|
---|
762 |
|
---|
763 | RTDECL(void) RTSha512t256Final(PRTSHA512T256CONTEXT pCtx, uint8_t pabDigest[RTSHA512T256_HASH_SIZE])
|
---|
764 | {
|
---|
765 | rtSha512FinalInternal(pCtx);
|
---|
766 | memcpy(pabDigest, &pCtx->AltPrivate.auH[0], RTSHA512T256_HASH_SIZE);
|
---|
767 | RT_ZERO(pCtx->AltPrivate.auH);
|
---|
768 | }
|
---|
769 | RT_EXPORT_SYMBOL(RTSha512t256Final);
|
---|
770 |
|
---|
771 |
|
---|
772 | RTDECL(void) RTSha512t256(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA512T256_HASH_SIZE])
|
---|
773 | {
|
---|
774 | RTSHA512T256CONTEXT Ctx;
|
---|
775 | RTSha512t256Init(&Ctx);
|
---|
776 | RTSha512t256Update(&Ctx, pvBuf, cbBuf);
|
---|
777 | RTSha512t256Final(&Ctx, pabDigest);
|
---|
778 | }
|
---|
779 | RT_EXPORT_SYMBOL(RTSha512t256);
|
---|
780 |
|
---|
781 |
|
---|
782 | RTDECL(bool) RTSha512t256Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA512T256_HASH_SIZE])
|
---|
783 | {
|
---|
784 | RTSHA512T256CONTEXT Ctx;
|
---|
785 | RTSha512t256Init(&Ctx);
|
---|
786 | RTSha512t256Update(&Ctx, pvBuf, cbBuf);
|
---|
787 | rtSha512FinalInternal(&Ctx);
|
---|
788 |
|
---|
789 | bool fRet = memcmp(pabHash, &Ctx.AltPrivate.auH[0], RTSHA512T256_HASH_SIZE) == 0;
|
---|
790 |
|
---|
791 | RT_ZERO(Ctx.AltPrivate.auH);
|
---|
792 | return fRet;
|
---|
793 | }
|
---|
794 | RT_EXPORT_SYMBOL(RTSha512t256Check);
|
---|
795 |
|
---|