← Back to branch summary

~ubuntu-branches/ubuntu/trusty/virtualbox-lts-xenial/trusty-proposed

« back to all changes in this revision

Viewing changes to src/VBox/Runtime/common/checksum/alt-sha512.cpp

  • Committer: Package Import Robot
  • Author(s): Gianfranco Costamagna
  • Date: 2016-02-23 14:28:26 UTC
  • Revision ID: package-import@ubuntu.com-20160223142826-bdu69el2z6wa2a44
Tags: upstream-4.3.36-dfsg
Import upstream version 4.3.36-dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Runtime/common/checksum/alt-sha512.cpp
 
1
/* $Id: alt-sha512.cpp $ */
 
2
/** @file
 
3
 * IPRT - SHA-512 and SHA-384 hash functions, Alternative Implementation.
 
4
 */
 
5
 
 
6
/*
 
7
 * Copyright (C) 2009-2014 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