alt-sha256.cpp@ 76408

Last change on this file since 76408 was 69111, checked in by vboxsync, 7 years ago
(C) year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.7 KB

Line
1	/* $Id: alt-sha256.cpp 69111 2017-10-17 14:26:02Z vboxsync $ */
2	/** @file
3	* IPRT - SHA-256 and SHA-224 hash functions, Alternative Implementation.
4	*/
5
6	/*
7	* Copyright (C) 2009-2017 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-256 block size (in bytes). */
32	#define RTSHA256_BLOCK_SIZE 64U
33
34	/** Enables the unrolled code. */
35	#define RTSHA256_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 RTSHA256ALTPRIVATECTX
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	uint32_t auW[64];
56	/** The message length (in bytes). */
57	uint64_t cbMessage;
58	/** The 8 hash values. */
59	uint32_t auH[8];
60	} RTSHA256ALTPRIVATECTX;
61
62	#define RT_SHA256_PRIVATE_ALT_CONTEXT
63	#include <iprt/sha.h>
64
65
66	AssertCompile(RT_SIZEOFMEMB(RTSHA256CONTEXT, abPadding) >= RT_SIZEOFMEMB(RTSHA256CONTEXT, AltPrivate));
67	AssertCompileMemberSize(RTSHA256ALTPRIVATECTX, auH, RTSHA256_HASH_SIZE);
68
69
70	/*********************************************************************************************************************************
71	* Global Variables *
72	*********************************************************************************************************************************/
73	#ifndef RTSHA256_UNROLLED
74	/** The K constants */
75	static uint32_t const g_auKs[] =
76	{
77	UINT32_C(0x428a2f98), UINT32_C(0x71374491), UINT32_C(0xb5c0fbcf), UINT32_C(0xe9b5dba5),
78	UINT32_C(0x3956c25b), UINT32_C(0x59f111f1), UINT32_C(0x923f82a4), UINT32_C(0xab1c5ed5),
79	UINT32_C(0xd807aa98), UINT32_C(0x12835b01), UINT32_C(0x243185be), UINT32_C(0x550c7dc3),
80	UINT32_C(0x72be5d74), UINT32_C(0x80deb1fe), UINT32_C(0x9bdc06a7), UINT32_C(0xc19bf174),
81	UINT32_C(0xe49b69c1), UINT32_C(0xefbe4786), UINT32_C(0x0fc19dc6), UINT32_C(0x240ca1cc),
82	UINT32_C(0x2de92c6f), UINT32_C(0x4a7484aa), UINT32_C(0x5cb0a9dc), UINT32_C(0x76f988da),
83	UINT32_C(0x983e5152), UINT32_C(0xa831c66d), UINT32_C(0xb00327c8), UINT32_C(0xbf597fc7),
84	UINT32_C(0xc6e00bf3), UINT32_C(0xd5a79147), UINT32_C(0x06ca6351), UINT32_C(0x14292967),
85	UINT32_C(0x27b70a85), UINT32_C(0x2e1b2138), UINT32_C(0x4d2c6dfc), UINT32_C(0x53380d13),
86	UINT32_C(0x650a7354), UINT32_C(0x766a0abb), UINT32_C(0x81c2c92e), UINT32_C(0x92722c85),
87	UINT32_C(0xa2bfe8a1), UINT32_C(0xa81a664b), UINT32_C(0xc24b8b70), UINT32_C(0xc76c51a3),
88	UINT32_C(0xd192e819), UINT32_C(0xd6990624), UINT32_C(0xf40e3585), UINT32_C(0x106aa070),
89	UINT32_C(0x19a4c116), UINT32_C(0x1e376c08), UINT32_C(0x2748774c), UINT32_C(0x34b0bcb5),
90	UINT32_C(0x391c0cb3), UINT32_C(0x4ed8aa4a), UINT32_C(0x5b9cca4f), UINT32_C(0x682e6ff3),
91	UINT32_C(0x748f82ee), UINT32_C(0x78a5636f), UINT32_C(0x84c87814), UINT32_C(0x8cc70208),
92	UINT32_C(0x90befffa), UINT32_C(0xa4506ceb), UINT32_C(0xbef9a3f7), UINT32_C(0xc67178f2),
93	};
94	#endif /* !RTSHA256_UNROLLED */
95
96
97
98	RTDECL(void) RTSha256Init(PRTSHA256CONTEXT pCtx)
99	{
100	pCtx->AltPrivate.cbMessage = 0;
101	pCtx->AltPrivate.auH[0] = UINT32_C(0x6a09e667);
102	pCtx->AltPrivate.auH[1] = UINT32_C(0xbb67ae85);
103	pCtx->AltPrivate.auH[2] = UINT32_C(0x3c6ef372);
104	pCtx->AltPrivate.auH[3] = UINT32_C(0xa54ff53a);
105	pCtx->AltPrivate.auH[4] = UINT32_C(0x510e527f);
106	pCtx->AltPrivate.auH[5] = UINT32_C(0x9b05688c);
107	pCtx->AltPrivate.auH[6] = UINT32_C(0x1f83d9ab);
108	pCtx->AltPrivate.auH[7] = UINT32_C(0x5be0cd19);
109	}
110	RT_EXPORT_SYMBOL(RTSha256Init);
111
112
113	/** Function 4.2. */
114	DECL_FORCE_INLINE(uint32_t) rtSha256Ch(uint32_t uX, uint32_t uY, uint32_t uZ)
115	{
116	#if 1
117	/* Optimization that saves one operation and probably a temporary variable. */
118	uint32_t uResult = uY;
119	uResult ^= uZ;
120	uResult &= uX;
121	uResult ^= uZ;
122	return uResult;
123	#else
124	/* The original. */
125	uint32_t uResult = uX & uY;
126	uResult ^= ~uX & uZ;
127	return uResult;
128	#endif
129	}
130
131
132	/** Function 4.3. */
133	DECL_FORCE_INLINE(uint32_t) rtSha256Maj(uint32_t uX, uint32_t uY, uint32_t uZ)
134	{
135	#if 1
136	/* Optimization that save one operation and probably a temporary variable. */
137	uint32_t uResult = uY;
138	uResult ^= uZ;
139	uResult &= uX;
140	uResult ^= uY & uZ;
141	return uResult;
142	#else
143	/* The original. */
144	uint32_t uResult = uX & uY;
145	uResult ^= uX & uZ;
146	uResult ^= uY & uZ;
147	return uResult;
148	#endif
149	}
150
151
152	/** Function 4.4. */
153	DECL_FORCE_INLINE(uint32_t) rtSha256CapitalSigma0(uint32_t uX)
154	{
155	uint32_t uResult = uX = ASMRotateRightU32(uX, 2);
156	uX = ASMRotateRightU32(uX, 13 - 2);
157	uResult ^= uX;
158	uX = ASMRotateRightU32(uX, 22 - 13);
159	uResult ^= uX;
160	return uResult;
161	}
162
163
164	/** Function 4.5. */
165	DECL_FORCE_INLINE(uint32_t) rtSha256CapitalSigma1(uint32_t uX)
166	{
167	uint32_t uResult = uX = ASMRotateRightU32(uX, 6);
168	uX = ASMRotateRightU32(uX, 11 - 6);
169	uResult ^= uX;
170	uX = ASMRotateRightU32(uX, 25 - 11);
171	uResult ^= uX;
172	return uResult;
173	}
174
175
176	/** Function 4.6. */
177	DECL_FORCE_INLINE(uint32_t) rtSha256SmallSigma0(uint32_t uX)
178	{
179	uint32_t uResult = uX >> 3;
180	uX = ASMRotateRightU32(uX, 7);
181	uResult ^= uX;
182	uX = ASMRotateRightU32(uX, 18 - 7);
183	uResult ^= uX;
184	return uResult;
185	}
186
187
188	/** Function 4.7. */
189	DECL_FORCE_INLINE(uint32_t) rtSha256SmallSigma1(uint32_t uX)
190	{
191	uint32_t uResult = uX >> 10;
192	uX = ASMRotateRightU32(uX, 17);
193	uResult ^= uX;
194	uX = ASMRotateRightU32(uX, 19 - 17);
195	uResult ^= uX;
196	return uResult;
197	}
198
199
200	/**
201	* Initializes the auW array from the specfied input block.
202	*
203	* @param pCtx The SHA-256 context.
204	* @param pbBlock The block. Must be arch-bit-width aligned.
205	*/
206	DECLINLINE(void) rtSha256BlockInit(PRTSHA256CONTEXT pCtx, uint8_t const *pbBlock)
207	{
208	#ifdef RTSHA256_UNROLLED
209	/* Copy and byte-swap the block. Initializing the rest of the Ws are done
210	in the processing loop. */
211	# ifdef RT_LITTLE_ENDIAN
212	# if 0 /* Just an idea... very little gain as this isn't the expensive code. */
213	__m128i const uBSwapConst = { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
214	__m128i const puSrc = (__m128i const )pbBlock;
215	__m128i puDst = (__m128i )&pCtx->AltPrivate.auW[0];
216
217	_mm_storeu_si128(puDst, _mm_shuffle_epi8(_mm_loadu_si128(puSrc), uBSwapConst)); puDst++; puSrc++;
218	_mm_storeu_si128(puDst, _mm_shuffle_epi8(_mm_loadu_si128(puSrc), uBSwapConst)); puDst++; puSrc++;
219	_mm_storeu_si128(puDst, _mm_shuffle_epi8(_mm_loadu_si128(puSrc), uBSwapConst)); puDst++; puSrc++;
220	_mm_storeu_si128(puDst, _mm_shuffle_epi8(_mm_loadu_si128(puSrc), uBSwapConst)); puDst++; puSrc++;
221
222	# elif ARCH_BITS == 64
223	uint64_t const puSrc = (uint64_t const )pbBlock;
224	uint64_t puW = (uint64_t )&pCtx->AltPrivate.auW[0];
225	Assert(!((uintptr_t)puSrc & 7));
226	Assert(!((uintptr_t)puW & 7));
227
228	/* b0 b1 b2 b3 b4 b5 b6 b7 --bwap--> b7 b6 b5 b4 b3 b2 b1 b0 --ror--> b3 b2 b1 b0 b7 b6 b5 b4; */
229	puW++ = ASMRotateRightU64(ASMByteSwapU64(puSrc++), 32);
230	puW++ = ASMRotateRightU64(ASMByteSwapU64(puSrc++), 32);
231	puW++ = ASMRotateRightU64(ASMByteSwapU64(puSrc++), 32);
232	puW++ = ASMRotateRightU64(ASMByteSwapU64(puSrc++), 32);
233
234	puW++ = ASMRotateRightU64(ASMByteSwapU64(puSrc++), 32);
235	puW++ = ASMRotateRightU64(ASMByteSwapU64(puSrc++), 32);
236	puW++ = ASMRotateRightU64(ASMByteSwapU64(puSrc++), 32);
237	puW++ = ASMRotateRightU64(ASMByteSwapU64(puSrc++), 32);
238
239	# else
240	uint32_t const puSrc = (uint32_t const )pbBlock;
241	uint32_t *puW = &pCtx->AltPrivate.auW[0];
242	Assert(!((uintptr_t)puSrc & 3));
243	Assert(!((uintptr_t)puW & 3));
244
245	puW++ = ASMByteSwapU32(puSrc++);
246	puW++ = ASMByteSwapU32(puSrc++);
247	puW++ = ASMByteSwapU32(puSrc++);
248	puW++ = ASMByteSwapU32(puSrc++);
249
250	puW++ = ASMByteSwapU32(puSrc++);
251	puW++ = ASMByteSwapU32(puSrc++);
252	puW++ = ASMByteSwapU32(puSrc++);
253	puW++ = ASMByteSwapU32(puSrc++);
254
255	puW++ = ASMByteSwapU32(puSrc++);
256	puW++ = ASMByteSwapU32(puSrc++);
257	puW++ = ASMByteSwapU32(puSrc++);
258	puW++ = ASMByteSwapU32(puSrc++);
259
260	puW++ = ASMByteSwapU32(puSrc++);
261	puW++ = ASMByteSwapU32(puSrc++);
262	puW++ = ASMByteSwapU32(puSrc++);
263	puW++ = ASMByteSwapU32(puSrc++);
264	# endif
265	# else /* RT_BIG_ENDIAN */
266	memcpy(&pCtx->AltPrivate.auW[0], pbBlock, RTSHA256_BLOCK_SIZE);
267	# endif /* RT_BIG_ENDIAN */
268
269	#else /* !RTSHA256_UNROLLED */
270	uint32_t const pu32Block = (uint32_t const )pbBlock;
271	Assert(!((uintptr_t)pu32Block & 3));
272
273	unsigned iWord;
274	for (iWord = 0; iWord < 16; iWord++)
275	pCtx->AltPrivate.auW[iWord] = RT_BE2H_U32(pu32Block[iWord]);
276
277	for (; iWord < RT_ELEMENTS(pCtx->AltPrivate.auW); iWord++)
278	{
279	uint32_t u32 = rtSha256SmallSigma1(pCtx->AltPrivate.auW[iWord - 2]);
280	u32 += rtSha256SmallSigma0(pCtx->AltPrivate.auW[iWord - 15]);
281	u32 += pCtx->AltPrivate.auW[iWord - 7];
282	u32 += pCtx->AltPrivate.auW[iWord - 16];
283	pCtx->AltPrivate.auW[iWord] = u32;
284	}
285	#endif /* !RTSHA256_UNROLLED */
286	}
287
288
289	/**
290	* Initializes the auW array from data buffered in the first part of the array.
291	*
292	* @param pCtx The SHA-256 context.
293	*/
294	DECLINLINE(void) rtSha256BlockInitBuffered(PRTSHA256CONTEXT pCtx)
295	{
296	#ifdef RTSHA256_UNROLLED
297	/* Do the byte swap if necessary. Initializing the rest of the Ws are done
298	in the processing loop. */
299	# ifdef RT_LITTLE_ENDIAN
300	# if ARCH_BITS == 64
301	uint64_t puW = (uint64_t )&pCtx->AltPrivate.auW[0];
302	Assert(!((uintptr_t)puW & 7));
303	/* b0 b1 b2 b3 b4 b5 b6 b7 --bwap--> b7 b6 b5 b4 b3 b2 b1 b0 --ror--> b3 b2 b1 b0 b7 b6 b5 b4; */
304	puW = ASMRotateRightU64(ASMByteSwapU64(puW), 32); puW++;
305	puW = ASMRotateRightU64(ASMByteSwapU64(puW), 32); puW++;
306	puW = ASMRotateRightU64(ASMByteSwapU64(puW), 32); puW++;
307	puW = ASMRotateRightU64(ASMByteSwapU64(puW), 32); puW++;
308
309	puW = ASMRotateRightU64(ASMByteSwapU64(puW), 32); puW++;
310	puW = ASMRotateRightU64(ASMByteSwapU64(puW), 32); puW++;
311	puW = ASMRotateRightU64(ASMByteSwapU64(puW), 32); puW++;
312	puW = ASMRotateRightU64(ASMByteSwapU64(puW), 32); puW++;
313
314	# else
315	uint32_t *puW = &pCtx->AltPrivate.auW[0];
316	Assert(!((uintptr_t)puW & 3));
317
318	puW = ASMByteSwapU32(puW); puW++;
319	puW = ASMByteSwapU32(puW); puW++;
320	puW = ASMByteSwapU32(puW); puW++;
321	puW = ASMByteSwapU32(puW); puW++;
322
323	puW = ASMByteSwapU32(puW); puW++;
324	puW = ASMByteSwapU32(puW); puW++;
325	puW = ASMByteSwapU32(puW); puW++;
326	puW = ASMByteSwapU32(puW); puW++;
327
328	puW = ASMByteSwapU32(puW); puW++;
329	puW = ASMByteSwapU32(puW); puW++;
330	puW = ASMByteSwapU32(puW); puW++;
331	puW = ASMByteSwapU32(puW); puW++;
332
333	puW = ASMByteSwapU32(puW); puW++;
334	puW = ASMByteSwapU32(puW); puW++;
335	puW = ASMByteSwapU32(puW); puW++;
336	puW = ASMByteSwapU32(puW); puW++;
337	# endif
338	# endif
339
340	#else /* !RTSHA256_UNROLLED */
341	unsigned iWord;
342	for (iWord = 0; iWord < 16; iWord++)
343	pCtx->AltPrivate.auW[iWord] = RT_BE2H_U32(pCtx->AltPrivate.auW[iWord]);
344
345	for (; iWord < RT_ELEMENTS(pCtx->AltPrivate.auW); iWord++)
346	{
347	uint32_t u32 = rtSha256SmallSigma1(pCtx->AltPrivate.auW[iWord - 2]);
348	u32 += rtSha256SmallSigma0(pCtx->AltPrivate.auW[iWord - 15]);
349	u32 += pCtx->AltPrivate.auW[iWord - 7];
350	u32 += pCtx->AltPrivate.auW[iWord - 16];
351	pCtx->AltPrivate.auW[iWord] = u32;
352	}
353	#endif /* !RTSHA256_UNROLLED */
354	}
355
356
357	/**
358	* Process the current block.
359	*
360	* Requires one of the rtSha256BlockInit functions to be called first.
361	*
362	* @param pCtx The SHA-256 context.
363	*/
364	static void rtSha256BlockProcess(PRTSHA256CONTEXT pCtx)
365	{
366	uint32_t uA = pCtx->AltPrivate.auH[0];
367	uint32_t uB = pCtx->AltPrivate.auH[1];
368	uint32_t uC = pCtx->AltPrivate.auH[2];
369	uint32_t uD = pCtx->AltPrivate.auH[3];
370	uint32_t uE = pCtx->AltPrivate.auH[4];
371	uint32_t uF = pCtx->AltPrivate.auH[5];
372	uint32_t uG = pCtx->AltPrivate.auH[6];
373	uint32_t uH = pCtx->AltPrivate.auH[7];
374
375	#ifdef RTSHA256_UNROLLED
376	uint32_t *puW = &pCtx->AltPrivate.auW[0];
377	# define RTSHA256_BODY(a_iWord, a_uK, a_uA, a_uB, a_uC, a_uD, a_uE, a_uF, a_uG, a_uH) \
378	do { \
379	if ((a_iWord) < 16) \
380	a_uH += *puW++; \
381	else \
382	{ \
383	uint32_t u32 = puW[-16]; \
384	u32 += rtSha256SmallSigma0(puW[-15]); \
385	u32 += puW[-7]; \
386	u32 += rtSha256SmallSigma1(puW[-2]); \
387	if (a_iWord < 64-2) *puW++ = u32; else puW++; \
388	a_uH += u32; \
389	} \
390	\
391	a_uH += rtSha256CapitalSigma1(a_uE); \
392	a_uH += a_uK; \
393	a_uH += rtSha256Ch(a_uE, a_uF, a_uG); \
394	a_uD += a_uH; \
395	\
396	a_uH += rtSha256CapitalSigma0(a_uA); \
397	a_uH += rtSha256Maj(a_uA, a_uB, a_uC); \
398	} while (0)
399	# define RTSHA256_EIGHT(a_uK0, a_uK1, a_uK2, a_uK3, a_uK4, a_uK5, a_uK6, a_uK7, a_iFirst) \
400	do { \
401	RTSHA256_BODY(a_iFirst + 0, a_uK0, uA, uB, uC, uD, uE, uF, uG, uH); \
402	RTSHA256_BODY(a_iFirst + 1, a_uK1, uH, uA, uB, uC, uD, uE, uF, uG); \
403	RTSHA256_BODY(a_iFirst + 2, a_uK2, uG, uH, uA, uB, uC, uD, uE, uF); \
404	RTSHA256_BODY(a_iFirst + 3, a_uK3, uF, uG, uH, uA, uB, uC, uD, uE); \
405	RTSHA256_BODY(a_iFirst + 4, a_uK4, uE, uF, uG, uH, uA, uB, uC, uD); \
406	RTSHA256_BODY(a_iFirst + 5, a_uK5, uD, uE, uF, uG, uH, uA, uB, uC); \
407	RTSHA256_BODY(a_iFirst + 6, a_uK6, uC, uD, uE, uF, uG, uH, uA, uB); \
408	RTSHA256_BODY(a_iFirst + 7, a_uK7, uB, uC, uD, uE, uF, uG, uH, uA); \
409	} while (0)
410	RTSHA256_EIGHT(UINT32_C(0x428a2f98), UINT32_C(0x71374491), UINT32_C(0xb5c0fbcf), UINT32_C(0xe9b5dba5),
411	UINT32_C(0x3956c25b), UINT32_C(0x59f111f1), UINT32_C(0x923f82a4), UINT32_C(0xab1c5ed5), 0);
412	RTSHA256_EIGHT(UINT32_C(0xd807aa98), UINT32_C(0x12835b01), UINT32_C(0x243185be), UINT32_C(0x550c7dc3),
413	UINT32_C(0x72be5d74), UINT32_C(0x80deb1fe), UINT32_C(0x9bdc06a7), UINT32_C(0xc19bf174), 8);
414	RTSHA256_EIGHT(UINT32_C(0xe49b69c1), UINT32_C(0xefbe4786), UINT32_C(0x0fc19dc6), UINT32_C(0x240ca1cc),
415	UINT32_C(0x2de92c6f), UINT32_C(0x4a7484aa), UINT32_C(0x5cb0a9dc), UINT32_C(0x76f988da), 16);
416	RTSHA256_EIGHT(UINT32_C(0x983e5152), UINT32_C(0xa831c66d), UINT32_C(0xb00327c8), UINT32_C(0xbf597fc7),
417	UINT32_C(0xc6e00bf3), UINT32_C(0xd5a79147), UINT32_C(0x06ca6351), UINT32_C(0x14292967), 24);
418	RTSHA256_EIGHT(UINT32_C(0x27b70a85), UINT32_C(0x2e1b2138), UINT32_C(0x4d2c6dfc), UINT32_C(0x53380d13),
419	UINT32_C(0x650a7354), UINT32_C(0x766a0abb), UINT32_C(0x81c2c92e), UINT32_C(0x92722c85), 32);
420	RTSHA256_EIGHT(UINT32_C(0xa2bfe8a1), UINT32_C(0xa81a664b), UINT32_C(0xc24b8b70), UINT32_C(0xc76c51a3),
421	UINT32_C(0xd192e819), UINT32_C(0xd6990624), UINT32_C(0xf40e3585), UINT32_C(0x106aa070), 40);
422	RTSHA256_EIGHT(UINT32_C(0x19a4c116), UINT32_C(0x1e376c08), UINT32_C(0x2748774c), UINT32_C(0x34b0bcb5),
423	UINT32_C(0x391c0cb3), UINT32_C(0x4ed8aa4a), UINT32_C(0x5b9cca4f), UINT32_C(0x682e6ff3), 48);
424	RTSHA256_EIGHT(UINT32_C(0x748f82ee), UINT32_C(0x78a5636f), UINT32_C(0x84c87814), UINT32_C(0x8cc70208),
425	UINT32_C(0x90befffa), UINT32_C(0xa4506ceb), UINT32_C(0xbef9a3f7), UINT32_C(0xc67178f2), 56);
426
427	#else /* !RTSHA256_UNROLLED */
428	for (unsigned iWord = 0; iWord < RT_ELEMENTS(pCtx->AltPrivate.auW); iWord++)
429	{
430	uint32_t uT1 = uH;
431	uT1 += rtSha256CapitalSigma1(uE);
432	uT1 += rtSha256Ch(uE, uF, uG);
433	uT1 += g_auKs[iWord];
434	uT1 += pCtx->AltPrivate.auW[iWord];
435
436	uint32_t uT2 = rtSha256CapitalSigma0(uA);
437	uT2 += rtSha256Maj(uA, uB, uC);
438
439	uH = uG;
440	uG = uF;
441	uF = uE;
442	uE = uD + uT1;
443	uD = uC;
444	uC = uB;
445	uB = uA;
446	uA = uT1 + uT2;
447	}
448	#endif /* !RTSHA256_UNROLLED */
449
450	pCtx->AltPrivate.auH[0] += uA;
451	pCtx->AltPrivate.auH[1] += uB;
452	pCtx->AltPrivate.auH[2] += uC;
453	pCtx->AltPrivate.auH[3] += uD;
454	pCtx->AltPrivate.auH[4] += uE;
455	pCtx->AltPrivate.auH[5] += uF;
456	pCtx->AltPrivate.auH[6] += uG;
457	pCtx->AltPrivate.auH[7] += uH;
458	}
459
460
461	RTDECL(void) RTSha256Update(PRTSHA256CONTEXT pCtx, const void *pvBuf, size_t cbBuf)
462	{
463	Assert(pCtx->AltPrivate.cbMessage < UINT64_MAX / 8);
464	uint8_t const pbBuf = (uint8_t const )pvBuf;
465
466	/*
467	* Deal with buffered bytes first.
468	*/
469	size_t cbBuffered = (size_t)pCtx->AltPrivate.cbMessage & (RTSHA256_BLOCK_SIZE - 1U);
470	if (cbBuffered)
471	{
472	size_t cbMissing = RTSHA256_BLOCK_SIZE - cbBuffered;
473	if (cbBuf >= cbMissing)
474	{
475	memcpy((uint8_t *)&pCtx->AltPrivate.auW[0] + cbBuffered, pbBuf, cbMissing);
476	pCtx->AltPrivate.cbMessage += cbMissing;
477	pbBuf += cbMissing;
478	cbBuf -= cbMissing;
479
480	rtSha256BlockInitBuffered(pCtx);
481	rtSha256BlockProcess(pCtx);
482	}
483	else
484	{
485	memcpy((uint8_t *)&pCtx->AltPrivate.auW[0] + cbBuffered, pbBuf, cbBuf);
486	pCtx->AltPrivate.cbMessage += cbBuf;
487	return;
488	}
489	}
490
491	if (!((uintptr_t)pbBuf & (sizeof(void *) - 1)))
492	{
493	/*
494	* Process full blocks directly from the input buffer.
495	*/
496	while (cbBuf >= RTSHA256_BLOCK_SIZE)
497	{
498	rtSha256BlockInit(pCtx, pbBuf);
499	rtSha256BlockProcess(pCtx);
500
501	pCtx->AltPrivate.cbMessage += RTSHA256_BLOCK_SIZE;
502	pbBuf += RTSHA256_BLOCK_SIZE;
503	cbBuf -= RTSHA256_BLOCK_SIZE;
504	}
505	}
506	else
507	{
508	/*
509	* Unaligned input, so buffer it.
510	*/
511	while (cbBuf >= RTSHA256_BLOCK_SIZE)
512	{
513	memcpy((uint8_t *)&pCtx->AltPrivate.auW[0], pbBuf, RTSHA256_BLOCK_SIZE);
514	rtSha256BlockInitBuffered(pCtx);
515	rtSha256BlockProcess(pCtx);
516
517	pCtx->AltPrivate.cbMessage += RTSHA256_BLOCK_SIZE;
518	pbBuf += RTSHA256_BLOCK_SIZE;
519	cbBuf -= RTSHA256_BLOCK_SIZE;
520	}
521	}
522
523	/*
524	* Stash any remaining bytes into the context buffer.
525	*/
526	if (cbBuf > 0)
527	{
528	memcpy((uint8_t *)&pCtx->AltPrivate.auW[0], pbBuf, cbBuf);
529	pCtx->AltPrivate.cbMessage += cbBuf;
530	}
531	}
532	RT_EXPORT_SYMBOL(RTSha256Update);
533
534
535	/**
536	* Internal worker for RTSha256Final and RTSha224Final that finalizes the
537	* computation but does not copy out the hash value.
538	*
539	* @param pCtx The SHA-256 context.
540	*/
541	static void rtSha256FinalInternal(PRTSHA256CONTEXT pCtx)
542	{
543	Assert(pCtx->AltPrivate.cbMessage < UINT64_MAX / 8);
544
545	/*
546	* Complete the message by adding a single bit (0x80), padding till
547	* the next 448-bit boundrary, the add the message length.
548	*/
549	uint64_t const cMessageBits = pCtx->AltPrivate.cbMessage * 8;
550
551	unsigned cbMissing = RTSHA256_BLOCK_SIZE - ((unsigned)pCtx->AltPrivate.cbMessage & (RTSHA256_BLOCK_SIZE - 1U));
552	static uint8_t const s_abSingleBitAndSomePadding[12] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
553	if (cbMissing < 1U + 8U)
554	/* Less than 64+8 bits left in the current block, force a new block. */
555	RTSha256Update(pCtx, &s_abSingleBitAndSomePadding, sizeof(s_abSingleBitAndSomePadding));
556	else
557	RTSha256Update(pCtx, &s_abSingleBitAndSomePadding, 1);
558
559	unsigned cbBuffered = (unsigned)pCtx->AltPrivate.cbMessage & (RTSHA256_BLOCK_SIZE - 1U);
560	cbMissing = RTSHA256_BLOCK_SIZE - cbBuffered;
561	Assert(cbMissing >= 8);
562	memset((uint8_t *)&pCtx->AltPrivate.auW[0] + cbBuffered, 0, cbMissing - 8);
563
564	(uint64_t )&pCtx->AltPrivate.auW[14] = RT_H2BE_U64(cMessageBits);
565
566	/*
567	* Process the last buffered block constructed/completed above.
568	*/
569	rtSha256BlockInitBuffered(pCtx);
570	rtSha256BlockProcess(pCtx);
571
572	/*
573	* Convert the byte order of the hash words and we're done.
574	*/
575	pCtx->AltPrivate.auH[0] = RT_H2BE_U32(pCtx->AltPrivate.auH[0]);
576	pCtx->AltPrivate.auH[1] = RT_H2BE_U32(pCtx->AltPrivate.auH[1]);
577	pCtx->AltPrivate.auH[2] = RT_H2BE_U32(pCtx->AltPrivate.auH[2]);
578	pCtx->AltPrivate.auH[3] = RT_H2BE_U32(pCtx->AltPrivate.auH[3]);
579	pCtx->AltPrivate.auH[4] = RT_H2BE_U32(pCtx->AltPrivate.auH[4]);
580	pCtx->AltPrivate.auH[5] = RT_H2BE_U32(pCtx->AltPrivate.auH[5]);
581	pCtx->AltPrivate.auH[6] = RT_H2BE_U32(pCtx->AltPrivate.auH[6]);
582	pCtx->AltPrivate.auH[7] = RT_H2BE_U32(pCtx->AltPrivate.auH[7]);
583
584	RT_ZERO(pCtx->AltPrivate.auW);
585	pCtx->AltPrivate.cbMessage = UINT64_MAX;
586	}
587	RT_EXPORT_SYMBOL(RTSha256Final);
588
589
590	RTDECL(void) RTSha256Final(PRTSHA256CONTEXT pCtx, uint8_t pabDigest[RTSHA256_HASH_SIZE])
591	{
592	rtSha256FinalInternal(pCtx);
593	memcpy(pabDigest, &pCtx->AltPrivate.auH[0], RTSHA256_HASH_SIZE);
594	RT_ZERO(pCtx->AltPrivate.auH);
595	}
596	RT_EXPORT_SYMBOL(RTSha256Final);
597
598
599	RTDECL(void) RTSha256(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA256_HASH_SIZE])
600	{
601	RTSHA256CONTEXT Ctx;
602	RTSha256Init(&Ctx);
603	RTSha256Update(&Ctx, pvBuf, cbBuf);
604	RTSha256Final(&Ctx, pabDigest);
605	}
606	RT_EXPORT_SYMBOL(RTSha256);
607
608
609	RTDECL(bool) RTSha256Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA256_HASH_SIZE])
610	{
611	RTSHA256CONTEXT Ctx;
612	RTSha256Init(&Ctx);
613	RTSha256Update(&Ctx, pvBuf, cbBuf);
614	rtSha256FinalInternal(&Ctx);
615
616	bool fRet = memcmp(pabHash, &Ctx.AltPrivate.auH[0], RTSHA256_HASH_SIZE) == 0;
617
618	RT_ZERO(Ctx.AltPrivate.auH);
619	return fRet;
620	}
621	RT_EXPORT_SYMBOL(RTSha256Check);
622
623
624
625	/*
626	* SHA-224 is just SHA-256 with different initial values an a truncated result.
627	*/
628
629	RTDECL(void) RTSha224Init(PRTSHA224CONTEXT pCtx)
630	{
631	pCtx->AltPrivate.cbMessage = 0;
632	pCtx->AltPrivate.auH[0] = UINT32_C(0xc1059ed8);
633	pCtx->AltPrivate.auH[1] = UINT32_C(0x367cd507);
634	pCtx->AltPrivate.auH[2] = UINT32_C(0x3070dd17);
635	pCtx->AltPrivate.auH[3] = UINT32_C(0xf70e5939);
636	pCtx->AltPrivate.auH[4] = UINT32_C(0xffc00b31);
637	pCtx->AltPrivate.auH[5] = UINT32_C(0x68581511);
638	pCtx->AltPrivate.auH[6] = UINT32_C(0x64f98fa7);
639	pCtx->AltPrivate.auH[7] = UINT32_C(0xbefa4fa4);
640	}
641	RT_EXPORT_SYMBOL(RTSha224Init);
642
643
644	RTDECL(void) RTSha224Update(PRTSHA224CONTEXT pCtx, const void *pvBuf, size_t cbBuf)
645	{
646	RTSha256Update(pCtx, pvBuf, cbBuf);
647	}
648	RT_EXPORT_SYMBOL(RTSha224Update);
649
650
651	RTDECL(void) RTSha224Final(PRTSHA224CONTEXT pCtx, uint8_t pabDigest[RTSHA224_HASH_SIZE])
652	{
653	rtSha256FinalInternal(pCtx);
654	memcpy(pabDigest, &pCtx->AltPrivate.auH[0], RTSHA224_HASH_SIZE);
655	RT_ZERO(pCtx->AltPrivate.auH);
656	}
657	RT_EXPORT_SYMBOL(RTSha224Final);
658
659
660	RTDECL(void) RTSha224(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA224_HASH_SIZE])
661	{
662	RTSHA224CONTEXT Ctx;
663	RTSha224Init(&Ctx);
664	RTSha224Update(&Ctx, pvBuf, cbBuf);
665	RTSha224Final(&Ctx, pabDigest);
666	}
667	RT_EXPORT_SYMBOL(RTSha224);
668
669
670	RTDECL(bool) RTSha224Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA224_HASH_SIZE])
671	{
672	RTSHA224CONTEXT Ctx;
673	RTSha224Init(&Ctx);
674	RTSha224Update(&Ctx, pvBuf, cbBuf);
675	rtSha256FinalInternal(&Ctx);
676
677	bool fRet = memcmp(pabHash, &Ctx.AltPrivate.auH[0], RTSHA224_HASH_SIZE) == 0;
678
679	RT_ZERO(Ctx.AltPrivate.auH);
680	return fRet;
681	}
682	RT_EXPORT_SYMBOL(RTSha224Check);
683

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

source: vbox/trunk/src/VBox/Runtime/common/checksum/alt-sha256.cpp@ 76408

Download in other formats: