alt-sha1.cpp@ 57358

Last change on this file since 57358 was 57358, checked in by vboxsync, 9 years ago
*: scm cleanup run.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 16.0 KB

Line
1	/* $Id: alt-sha1.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2	/** @file
3	* IPRT - SHA-1 hash functions, Alternative Implementation.
4	*/
5
6	/*
7	* Copyright (C) 2009-2015 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-1 block size (in bytes). */
32	#define RTSHA1_BLOCK_SIZE 64U
33
34	/** Enables the unrolled code. */
35	#define RTSHA1_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 RTSHA1ALTPRIVATECTX
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[80];
56	/** The message length (in bytes). */
57	uint64_t cbMessage;
58
59	/** The 5 hash values. */
60	uint32_t auH[5];
61	} RTSHA1ALTPRIVATECTX;
62
63	#define RT_SHA1_PRIVATE_ALT_CONTEXT
64	#include <iprt/sha.h>
65
66
67	AssertCompile(RT_SIZEOFMEMB(RTSHA1CONTEXT, abPadding) >= RT_SIZEOFMEMB(RTSHA1CONTEXT, AltPrivate));
68	AssertCompileMemberSize(RTSHA1ALTPRIVATECTX, auH, RTSHA1_HASH_SIZE);
69
70
71
72
73	RTDECL(void) RTSha1Init(PRTSHA1CONTEXT pCtx)
74	{
75	pCtx->AltPrivate.cbMessage = 0;
76	pCtx->AltPrivate.auH[0] = UINT32_C(0x67452301);
77	pCtx->AltPrivate.auH[1] = UINT32_C(0xefcdab89);
78	pCtx->AltPrivate.auH[2] = UINT32_C(0x98badcfe);
79	pCtx->AltPrivate.auH[3] = UINT32_C(0x10325476);
80	pCtx->AltPrivate.auH[4] = UINT32_C(0xc3d2e1f0);
81	}
82	RT_EXPORT_SYMBOL(RTSha1Init);
83
84
85	/**
86	* Initializes the auW array from the specfied input block.
87	*
88	* @param pCtx The SHA1 context.
89	* @param pbBlock The block. Must be 32-bit aligned.
90	*/
91	DECLINLINE(void) rtSha1BlockInit(PRTSHA1CONTEXT pCtx, uint8_t const *pbBlock)
92	{
93	#ifdef RTSHA1_UNROLLED
94	uint32_t const puSrc = (uint32_t const )pbBlock;
95	uint32_t *puW = &pCtx->AltPrivate.auW[0];
96	Assert(!((uintptr_t)puSrc & 3));
97	Assert(!((uintptr_t)puW & 3));
98
99	/* Copy and byte-swap the block. Initializing the rest of the Ws are done
100	in the processing loop. */
101	# ifdef RT_LITTLE_ENDIAN
102	puW++ = ASMByteSwapU32(puSrc++);
103	puW++ = ASMByteSwapU32(puSrc++);
104	puW++ = ASMByteSwapU32(puSrc++);
105	puW++ = ASMByteSwapU32(puSrc++);
106
107	puW++ = ASMByteSwapU32(puSrc++);
108	puW++ = ASMByteSwapU32(puSrc++);
109	puW++ = ASMByteSwapU32(puSrc++);
110	puW++ = ASMByteSwapU32(puSrc++);
111
112	puW++ = ASMByteSwapU32(puSrc++);
113	puW++ = ASMByteSwapU32(puSrc++);
114	puW++ = ASMByteSwapU32(puSrc++);
115	puW++ = ASMByteSwapU32(puSrc++);
116
117	puW++ = ASMByteSwapU32(puSrc++);
118	puW++ = ASMByteSwapU32(puSrc++);
119	puW++ = ASMByteSwapU32(puSrc++);
120	puW++ = ASMByteSwapU32(puSrc++);
121	# else
122	memcpy(puW, puSrc, RTSHA1_BLOCK_SIZE);
123	# endif
124
125	#else /* !RTSHA1_UNROLLED */
126	uint32_t const pu32Block = (uint32_t const )pbBlock;
127	Assert(!((uintptr_t)pu32Block & 3));
128
129	unsigned iWord;
130	for (iWord = 0; iWord < 16; iWord++)
131	pCtx->AltPrivate.auW[iWord] = RT_BE2H_U32(pu32Block[iWord]);
132
133	for (; iWord < RT_ELEMENTS(pCtx->AltPrivate.auW); iWord++)
134	{
135	uint32_t u32 = pCtx->AltPrivate.auW[iWord - 16];
136	u32 ^= pCtx->AltPrivate.auW[iWord - 14];
137	u32 ^= pCtx->AltPrivate.auW[iWord - 8];
138	u32 ^= pCtx->AltPrivate.auW[iWord - 3];
139	pCtx->AltPrivate.auW[iWord] = ASMRotateLeftU32(u32, 1);
140	}
141	#endif /* !RTSHA1_UNROLLED */
142	}
143
144
145	/**
146	* Initializes the auW array from data buffered in the first part of the array.
147	*
148	* @param pCtx The SHA1 context.
149	*/
150	DECLINLINE(void) rtSha1BlockInitBuffered(PRTSHA1CONTEXT pCtx)
151	{
152	#ifdef RTSHA1_UNROLLED
153	uint32_t *puW = &pCtx->AltPrivate.auW[0];
154	Assert(!((uintptr_t)puW & 3));
155
156	/* Do the byte swap if necessary. Initializing the rest of the Ws are done
157	in the processing loop. */
158	# ifdef RT_LITTLE_ENDIAN
159	puW = ASMByteSwapU32(puW); puW++;
160	puW = ASMByteSwapU32(puW); puW++;
161	puW = ASMByteSwapU32(puW); puW++;
162	puW = ASMByteSwapU32(puW); puW++;
163
164	puW = ASMByteSwapU32(puW); puW++;
165	puW = ASMByteSwapU32(puW); puW++;
166	puW = ASMByteSwapU32(puW); puW++;
167	puW = ASMByteSwapU32(puW); puW++;
168
169	puW = ASMByteSwapU32(puW); puW++;
170	puW = ASMByteSwapU32(puW); puW++;
171	puW = ASMByteSwapU32(puW); puW++;
172	puW = ASMByteSwapU32(puW); puW++;
173
174	puW = ASMByteSwapU32(puW); puW++;
175	puW = ASMByteSwapU32(puW); puW++;
176	puW = ASMByteSwapU32(puW); puW++;
177	puW = ASMByteSwapU32(puW); puW++;
178	# endif
179
180	#else /* !RTSHA1_UNROLLED_INIT */
181	unsigned iWord;
182	for (iWord = 0; iWord < 16; iWord++)
183	pCtx->AltPrivate.auW[iWord] = RT_BE2H_U32(pCtx->AltPrivate.auW[iWord]);
184
185	for (; iWord < RT_ELEMENTS(pCtx->AltPrivate.auW); iWord++)
186	{
187	uint32_t u32 = pCtx->AltPrivate.auW[iWord - 16];
188	u32 ^= pCtx->AltPrivate.auW[iWord - 14];
189	u32 ^= pCtx->AltPrivate.auW[iWord - 8];
190	u32 ^= pCtx->AltPrivate.auW[iWord - 3];
191	pCtx->AltPrivate.auW[iWord] = ASMRotateLeftU32(u32, 1);
192	}
193	#endif /* !RTSHA1_UNROLLED_INIT */
194	}
195
196
197	/** Function 4.1, Ch(x,y,z). */
198	DECL_FORCE_INLINE(uint32_t) rtSha1Ch(uint32_t uX, uint32_t uY, uint32_t uZ)
199	{
200	#if 1
201	/* Optimization that saves one operation and probably a temporary variable. */
202	uint32_t uResult = uY;
203	uResult ^= uZ;
204	uResult &= uX;
205	uResult ^= uZ;
206	return uResult;
207	#else
208	/* The original. */
209	uint32_t uResult = uX & uY;
210	uResult ^= ~uX & uZ;
211	return uResult;
212	#endif
213	}
214
215
216	/** Function 4.1, Parity(x,y,z). */
217	DECL_FORCE_INLINE(uint32_t) rtSha1Parity(uint32_t uX, uint32_t uY, uint32_t uZ)
218	{
219	uint32_t uResult = uX;
220	uResult ^= uY;
221	uResult ^= uZ;
222	return uResult;
223	}
224
225
226	/** Function 4.1, Maj(x,y,z). */
227	DECL_FORCE_INLINE(uint32_t) rtSha1Maj(uint32_t uX, uint32_t uY, uint32_t uZ)
228	{
229	#if 1
230	/* Optimization that save one operation and probably a temporary variable. */
231	uint32_t uResult = uY;
232	uResult ^= uZ;
233	uResult &= uX;
234	uResult ^= uY & uZ;
235	return uResult;
236	#else
237	/* The original. */
238	uint32_t uResult = (uX & uY);
239	uResult \|= (uX & uZ);
240	uResult \|= (uY & uZ);
241	return uResult;
242	#endif
243	}
244
245
246	/**
247	* Process the current block.
248	*
249	* Requires one of the rtSha1BlockInit functions to be called first.
250	*
251	* @param pCtx The SHA1 context.
252	*/
253	static void rtSha1BlockProcess(PRTSHA1CONTEXT pCtx)
254	{
255	uint32_t uA = pCtx->AltPrivate.auH[0];
256	uint32_t uB = pCtx->AltPrivate.auH[1];
257	uint32_t uC = pCtx->AltPrivate.auH[2];
258	uint32_t uD = pCtx->AltPrivate.auH[3];
259	uint32_t uE = pCtx->AltPrivate.auH[4];
260
261	#ifdef RTSHA1_UNROLLED
262	/* This fully unrolled version will avoid the variable rotation by
263	embedding it into the loop unrolling. */
264	uint32_t *puW = &pCtx->AltPrivate.auW[0];
265	# define SHA1_BODY(a_iWord, a_uK, a_fnFt, a_uA, a_uB, a_uC, a_uD, a_uE) \
266	do { \
267	if (a_iWord < 16) \
268	a_uE += *puW++; \
269	else \
270	{ \
271	uint32_t u32 = puW[-16]; \
272	u32 ^= puW[-14]; \
273	u32 ^= puW[-8]; \
274	u32 ^= puW[-3]; \
275	u32 = ASMRotateLeftU32(u32, 1); \
276	*puW++ = u32; \
277	a_uE += u32; \
278	} \
279	a_uE += (a_uK); \
280	a_uE += ASMRotateLeftU32(a_uA, 5); \
281	a_uE += a_fnFt(a_uB, a_uC, a_uD); \
282	a_uB = ASMRotateLeftU32(a_uB, 30); \
283	} while (0)
284	# define FIVE_ITERATIONS(a_iFirst, a_uK, a_fnFt) \
285	do { \
286	SHA1_BODY(a_iFirst + 0, a_uK, a_fnFt, uA, uB, uC, uD, uE); \
287	SHA1_BODY(a_iFirst + 1, a_uK, a_fnFt, uE, uA, uB, uC, uD); \
288	SHA1_BODY(a_iFirst + 2, a_uK, a_fnFt, uD, uE, uA, uB, uC); \
289	SHA1_BODY(a_iFirst + 3, a_uK, a_fnFt, uC, uD, uE, uA, uB); \
290	SHA1_BODY(a_iFirst + 4, a_uK, a_fnFt, uB, uC, uD, uE, uA); \
291	} while (0)
292	# define TWENTY_ITERATIONS(a_iStart, a_uK, a_fnFt) \
293	do { \
294	FIVE_ITERATIONS(a_iStart + 0, a_uK, a_fnFt); \
295	FIVE_ITERATIONS(a_iStart + 5, a_uK, a_fnFt); \
296	FIVE_ITERATIONS(a_iStart + 10, a_uK, a_fnFt); \
297	FIVE_ITERATIONS(a_iStart + 15, a_uK, a_fnFt); \
298	} while (0)
299
300	TWENTY_ITERATIONS( 0, UINT32_C(0x5a827999), rtSha1Ch);
301	TWENTY_ITERATIONS(20, UINT32_C(0x6ed9eba1), rtSha1Parity);
302	TWENTY_ITERATIONS(40, UINT32_C(0x8f1bbcdc), rtSha1Maj);
303	TWENTY_ITERATIONS(60, UINT32_C(0xca62c1d6), rtSha1Parity);
304
305	#elif 1 /* Version avoiding the constant selection. */
306	unsigned iWord = 0;
307	# define TWENTY_ITERATIONS(a_iWordStop, a_uK, a_uExprBCD) \
308	for (; iWord < a_iWordStop; iWord++) \
309	{ \
310	uint32_t uTemp = ASMRotateLeftU32(uA, 5); \
311	uTemp += (a_uExprBCD); \
312	uTemp += uE; \
313	uTemp += pCtx->AltPrivate.auW[iWord]; \
314	uTemp += (a_uK); \
315	\
316	uE = uD; \
317	uD = uC; \
318	uC = ASMRotateLeftU32(uB, 30); \
319	uB = uA; \
320	uA = uTemp; \
321	} do { } while (0)
322	TWENTY_ITERATIONS(20, UINT32_C(0x5a827999), rtSha1Ch(uB, uC, uD));
323	TWENTY_ITERATIONS(40, UINT32_C(0x6ed9eba1), rtSha1Parity(uB, uC, uD));
324	TWENTY_ITERATIONS(60, UINT32_C(0x8f1bbcdc), rtSha1Maj(uB, uC, uD));
325	TWENTY_ITERATIONS(80, UINT32_C(0xca62c1d6), rtSha1Parity(uB, uC, uD));
326
327	#else /* Dead simple implementation. */
328	for (unsigned iWord = 0; iWord < RT_ELEMENTS(pCtx->AltPrivate.auW); iWord++)
329	{
330	uint32_t uTemp = ASMRotateLeftU32(uA, 5);
331	uTemp += uE;
332	uTemp += pCtx->AltPrivate.auW[iWord];
333	if (iWord <= 19)
334	{
335	uTemp += (uB & uC) \| (~uB & uD);
336	uTemp += UINT32_C(0x5a827999);
337	}
338	else if (iWord <= 39)
339	{
340	uTemp += uB ^ uC ^ uD;
341	uTemp += UINT32_C(0x6ed9eba1);
342	}
343	else if (iWord <= 59)
344	{
345	uTemp += (uB & uC) \| (uB & uD) \| (uC & uD);
346	uTemp += UINT32_C(0x8f1bbcdc);
347	}
348	else
349	{
350	uTemp += uB ^ uC ^ uD;
351	uTemp += UINT32_C(0xca62c1d6);
352	}
353
354	uE = uD;
355	uD = uC;
356	uC = ASMRotateLeftU32(uB, 30);
357	uB = uA;
358	uA = uTemp;
359	}
360	#endif
361
362	pCtx->AltPrivate.auH[0] += uA;
363	pCtx->AltPrivate.auH[1] += uB;
364	pCtx->AltPrivate.auH[2] += uC;
365	pCtx->AltPrivate.auH[3] += uD;
366	pCtx->AltPrivate.auH[4] += uE;
367	}
368
369
370	RTDECL(void) RTSha1Update(PRTSHA1CONTEXT pCtx, const void *pvBuf, size_t cbBuf)
371	{
372	Assert(pCtx->AltPrivate.cbMessage < UINT64_MAX / 2);
373	uint8_t const pbBuf = (uint8_t const )pvBuf;
374
375	/*
376	* Deal with buffered bytes first.
377	*/
378	size_t cbBuffered = (size_t)pCtx->AltPrivate.cbMessage & (RTSHA1_BLOCK_SIZE - 1U);
379	if (cbBuffered)
380	{
381	size_t cbMissing = RTSHA1_BLOCK_SIZE - cbBuffered;
382	if (cbBuf >= cbMissing)
383	{
384	memcpy((uint8_t *)&pCtx->AltPrivate.auW[0] + cbBuffered, pbBuf, cbMissing);
385	pCtx->AltPrivate.cbMessage += cbMissing;
386	pbBuf += cbMissing;
387	cbBuf -= cbMissing;
388
389	rtSha1BlockInitBuffered(pCtx);
390	rtSha1BlockProcess(pCtx);
391	}
392	else
393	{
394	memcpy((uint8_t *)&pCtx->AltPrivate.auW[0] + cbBuffered, pbBuf, cbBuf);
395	pCtx->AltPrivate.cbMessage += cbBuf;
396	return;
397	}
398	}
399
400	if (!((uintptr_t)pbBuf & 3))
401	{
402	/*
403	* Process full blocks directly from the input buffer.
404	*/
405	while (cbBuf >= RTSHA1_BLOCK_SIZE)
406	{
407	rtSha1BlockInit(pCtx, pbBuf);
408	rtSha1BlockProcess(pCtx);
409
410	pCtx->AltPrivate.cbMessage += RTSHA1_BLOCK_SIZE;
411	pbBuf += RTSHA1_BLOCK_SIZE;
412	cbBuf -= RTSHA1_BLOCK_SIZE;
413	}
414	}
415	else
416	{
417	/*
418	* Unaligned input, so buffer it.
419	*/
420	while (cbBuf >= RTSHA1_BLOCK_SIZE)
421	{
422	memcpy((uint8_t *)&pCtx->AltPrivate.auW[0], pbBuf, RTSHA1_BLOCK_SIZE);
423	rtSha1BlockInitBuffered(pCtx);
424	rtSha1BlockProcess(pCtx);
425
426	pCtx->AltPrivate.cbMessage += RTSHA1_BLOCK_SIZE;
427	pbBuf += RTSHA1_BLOCK_SIZE;
428	cbBuf -= RTSHA1_BLOCK_SIZE;
429	}
430	}
431
432	/*
433	* Stash any remaining bytes into the context buffer.
434	*/
435	if (cbBuf > 0)
436	{
437	memcpy((uint8_t *)&pCtx->AltPrivate.auW[0], pbBuf, cbBuf);
438	pCtx->AltPrivate.cbMessage += cbBuf;
439	}
440	}
441	RT_EXPORT_SYMBOL(RTSha1Update);
442
443
444	RTDECL(void) RTSha1Final(PRTSHA1CONTEXT pCtx, uint8_t pabDigest[RTSHA1_HASH_SIZE])
445	{
446	Assert(pCtx->AltPrivate.cbMessage < UINT64_MAX / 2);
447
448	/*
449	* Complete the message by adding a single bit (0x80), padding till
450	* the next 448-bit boundrary, the add the message length.
451	*/
452	uint64_t const cMessageBits = pCtx->AltPrivate.cbMessage * 8;
453
454	unsigned cbMissing = RTSHA1_BLOCK_SIZE - ((unsigned)pCtx->AltPrivate.cbMessage & (RTSHA1_BLOCK_SIZE - 1U));
455	static uint8_t const s_abSingleBitAndSomePadding[12] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
456	if (cbMissing < 1U + 8U)
457	/* Less than 64+8 bits left in the current block, force a new block. */
458	RTSha1Update(pCtx, &s_abSingleBitAndSomePadding, sizeof(s_abSingleBitAndSomePadding));
459	else
460	RTSha1Update(pCtx, &s_abSingleBitAndSomePadding, 1);
461
462	unsigned cbBuffered = (unsigned)pCtx->AltPrivate.cbMessage & (RTSHA1_BLOCK_SIZE - 1U);
463	cbMissing = RTSHA1_BLOCK_SIZE - cbBuffered;
464	Assert(cbMissing >= 8);
465	memset((uint8_t *)&pCtx->AltPrivate.auW[0] + cbBuffered, 0, cbMissing - 8);
466
467	(uint64_t )&pCtx->AltPrivate.auW[14] = RT_H2BE_U64(cMessageBits);
468
469	/*
470	* Process the last buffered block constructed/completed above.
471	*/
472	rtSha1BlockInitBuffered(pCtx);
473	rtSha1BlockProcess(pCtx);
474
475	/*
476	* Convert the byte order of the hash words and we're done.
477	*/
478	pCtx->AltPrivate.auH[0] = RT_H2BE_U32(pCtx->AltPrivate.auH[0]);
479	pCtx->AltPrivate.auH[1] = RT_H2BE_U32(pCtx->AltPrivate.auH[1]);
480	pCtx->AltPrivate.auH[2] = RT_H2BE_U32(pCtx->AltPrivate.auH[2]);
481	pCtx->AltPrivate.auH[3] = RT_H2BE_U32(pCtx->AltPrivate.auH[3]);
482	pCtx->AltPrivate.auH[4] = RT_H2BE_U32(pCtx->AltPrivate.auH[4]);
483
484	memcpy(pabDigest, &pCtx->AltPrivate.auH[0], RTSHA1_HASH_SIZE);
485
486	RT_ZERO(pCtx->AltPrivate);
487	pCtx->AltPrivate.cbMessage = UINT64_MAX;
488	}
489	RT_EXPORT_SYMBOL(RTSha1Final);
490
491
492	RTDECL(void) RTSha1(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA1_HASH_SIZE])
493	{
494	RTSHA1CONTEXT Ctx;
495	RTSha1Init(&Ctx);
496	RTSha1Update(&Ctx, pvBuf, cbBuf);
497	RTSha1Final(&Ctx, pabDigest);
498	}
499	RT_EXPORT_SYMBOL(RTSha1);
500

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

source: vbox/trunk/src/VBox/Runtime/common/checksum/alt-sha1.cpp@ 57358

Download in other formats: