43#if CRYPTOPP_MSC_VERSION
44# pragma warning(disable: 4100 4731)
47#ifndef CRYPTOPP_IMPORTS
48#ifndef CRYPTOPP_GENERATE_X64_MASM
55#if defined(CRYPTOPP_DISABLE_SHA_ASM)
56# undef CRYPTOPP_X86_ASM_AVAILABLE
57# undef CRYPTOPP_X32_ASM_AVAILABLE
58# undef CRYPTOPP_X64_ASM_AVAILABLE
59# undef CRYPTOPP_SSE2_ASM_AVAILABLE
64#if CRYPTOPP_SHANI_AVAILABLE
65extern void SHA1_HashMultipleBlocks_SHANI(
word32 *state,
const word32 *data,
size_t length,
ByteOrder order);
66extern void SHA256_HashMultipleBlocks_SHANI(
word32 *state,
const word32 *data,
size_t length,
ByteOrder order);
69#if CRYPTOGAMS_ARM_SHA1
70extern "C" void cryptogams_sha1_block_data_order(
word32* state,
const word32 *data,
size_t blocks);
71extern "C" void cryptogams_sha1_block_data_order_neon(
word32* state,
const word32 *data,
size_t blocks);
74#if CRYPTOPP_ARM_SHA1_AVAILABLE
75extern void SHA1_HashMultipleBlocks_ARMV8(
word32 *state,
const word32 *data,
size_t length,
ByteOrder order);
78#if CRYPTOPP_ARM_SHA2_AVAILABLE
79extern void SHA256_HashMultipleBlocks_ARMV8(
word32 *state,
const word32 *data,
size_t length,
ByteOrder order);
82#if CRYPTOGAMS_ARM_SHA256
83extern "C" void cryptogams_sha256_block_data_order(
word32* state,
const word32 *data,
size_t blocks);
84extern "C" void cryptogams_sha256_block_data_order_neon(
word32* state,
const word32 *data,
size_t blocks);
87#if CRYPTOPP_ARM_SHA512_AVAILABLE
88extern void SHA512_HashMultipleBlocks_ARMV8(
word32 *state,
const word32 *data,
size_t length,
ByteOrder order);
91#if CRYPTOPP_POWER8_SHA_AVAILABLE
92extern void SHA256_HashMultipleBlocks_POWER8(
word32 *state,
const word32 *data,
size_t length,
ByteOrder order);
93extern void SHA512_HashMultipleBlocks_POWER8(
word64 *state,
const word64 *data,
size_t length,
ByteOrder order);
96#if CRYPTOGAMS_ARM_SHA512
97extern "C" void cryptogams_sha512_block_data_order(
word64* state,
const word64 *data,
size_t blocks);
98extern "C" void cryptogams_sha512_block_data_order_neon(
word64* state,
const word64 *data,
size_t blocks);
103extern const word32 SHA256_K[64];
104extern const word64 SHA512_K[80];
106CRYPTOPP_ALIGN_DATA(16)
107const
word64 SHA512_K[80] = {
150CRYPTOPP_ALIGN_DATA(16)
151const
word32 SHA256_K[64] = {
153 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
154 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
155 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
156 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
157 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
158 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
159 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
160 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
161 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
162 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
163 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
164 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
165 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
166 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
167 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
168 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
175ANONYMOUS_NAMESPACE_BEGIN
177#define blk0(i) (W[i] = data[i])
178#define blk1(i) (W[i&15] = rotlConstant<1>(W[(i+13)&15]^W[(i+8)&15]^W[(i+2)&15]^W[i&15]))
180#define f1(x,y,z) (z^(x&(y^z)))
181#define f2(x,y,z) (x^y^z)
182#define f3(x,y,z) ((x&y)|(z&(x|y)))
183#define f4(x,y,z) (x^y^z)
186#define R0(v,w,x,y,z,i) z+=f1(w,x,y)+blk0(i)+0x5A827999+rotlConstant<5>(v);w=rotlConstant<30>(w);
187#define R1(v,w,x,y,z,i) z+=f1(w,x,y)+blk1(i)+0x5A827999+rotlConstant<5>(v);w=rotlConstant<30>(w);
188#define R2(v,w,x,y,z,i) z+=f2(w,x,y)+blk1(i)+0x6ED9EBA1+rotlConstant<5>(v);w=rotlConstant<30>(w);
189#define R3(v,w,x,y,z,i) z+=f3(w,x,y)+blk1(i)+0x8F1BBCDC+rotlConstant<5>(v);w=rotlConstant<30>(w);
190#define R4(v,w,x,y,z,i) z+=f4(w,x,y)+blk1(i)+0xCA62C1D6+rotlConstant<5>(v);w=rotlConstant<30>(w);
192void SHA1_HashBlock_CXX(
word32 *state,
const word32 *data)
205 R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
206 R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
207 R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
208 R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
209 R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
210 R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
211 R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
212 R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
213 R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
214 R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
215 R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
216 R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
217 R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
218 R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
219 R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
220 R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
221 R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
222 R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
223 R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
224 R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
244ANONYMOUS_NAMESPACE_END
250std::string SHA1::AlgorithmProvider()
const
252#if CRYPTOPP_SHANI_AVAILABLE
256#if CRYPTOPP_SSE2_ASM_AVAILABLE
260#if CRYPTOGAMS_ARM_SHA1
266#if CRYPTOPP_ARM_SHA1_AVAILABLE
275 state[0] = 0x67452301;
276 state[1] = 0xEFCDAB89;
277 state[2] = 0x98BADCFE;
278 state[3] = 0x10325476;
279 state[4] = 0xC3D2E1F0;
287#if CRYPTOPP_SHANI_AVAILABLE
294#if CRYPTOGAMS_ARM_SHA1 && 0
297# if defined(CRYPTOPP_LITTLE_ENDIAN)
300 cryptogams_sha1_block_data_order_neon(state, data, 1);
302 cryptogams_sha1_block_data_order_neon(state, data, 1);
308# if defined(CRYPTOPP_LITTLE_ENDIAN)
311 cryptogams_sha1_block_data_order(state, data, 1);
313 cryptogams_sha1_block_data_order(state, data, 1);
318#if CRYPTOPP_ARM_SHA1_AVAILABLE
326 SHA1_HashBlock_CXX(state, data);
329size_t SHA1::HashMultipleBlocks(
const word32 *input,
size_t length)
334#if CRYPTOPP_SHANI_AVAILABLE
338 return length & (SHA1::BLOCKSIZE - 1);
341#if CRYPTOGAMS_ARM_SHA1
344 cryptogams_sha1_block_data_order_neon(m_state, input, length / SHA1::BLOCKSIZE);
345 return length & (SHA1::BLOCKSIZE - 1);
349 cryptogams_sha1_block_data_order(m_state, input, length / SHA1::BLOCKSIZE);
350 return length & (SHA1::BLOCKSIZE - 1);
353#if CRYPTOPP_ARM_SHA1_AVAILABLE
357 return length & (SHA1::BLOCKSIZE - 1);
362 word32 *dataBuf = this->DataBuf();
367 SHA1_HashBlock_CXX(m_state, input);
372 SHA1_HashBlock_CXX(m_state, dataBuf);
375 input += SHA1::BLOCKSIZE/
sizeof(
word32);
376 length -= SHA1::BLOCKSIZE;
378 while (length >= SHA1::BLOCKSIZE);
384ANONYMOUS_NAMESPACE_BEGIN
386#define a(i) T[(0-i)&7]
387#define b(i) T[(1-i)&7]
388#define c(i) T[(2-i)&7]
389#define d(i) T[(3-i)&7]
390#define e(i) T[(4-i)&7]
391#define f(i) T[(5-i)&7]
392#define g(i) T[(6-i)&7]
393#define h(i) T[(7-i)&7]
395#define blk0(i) (W[i] = data[i])
396#define blk2(i) (W[i&15]+=s1(W[(i-2)&15])+W[(i-7)&15]+s0(W[(i-15)&15]))
398#define Ch(x,y,z) (z^(x&(y^z)))
399#define Maj(x,y,z) (y^((x^y)&(y^z)))
401#define R(i) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+SHA256_K[i+j]+(j?blk2(i):blk0(i));\
402 d(i)+=h(i);h(i)+=S0(a(i))+Maj(a(i),b(i),c(i))
405#define s0(x) (rotrConstant<7>(x)^rotrConstant<18>(x)^(x>>3))
406#define s1(x) (rotrConstant<17>(x)^rotrConstant<19>(x)^(x>>10))
407#define S0(x) (rotrConstant<2>(x)^rotrConstant<13>(x)^rotrConstant<22>(x))
408#define S1(x) (rotrConstant<6>(x)^rotrConstant<11>(x)^rotrConstant<25>(x))
410void SHA256_HashBlock_CXX(
word32 *state,
const word32 *data)
414 memcpy(T, state,
sizeof(T));
416 for (
unsigned int j=0; j<64; j+=16)
418 R( 0); R( 1); R( 2); R( 3);
419 R( 4); R( 5); R( 6); R( 7);
420 R( 8); R( 9); R(10); R(11);
421 R(12); R(13); R(14); R(15);
454ANONYMOUS_NAMESPACE_END
456std::string SHA256_AlgorithmProvider()
458#if CRYPTOPP_SHANI_AVAILABLE
462#if CRYPTOPP_SSE2_ASM_AVAILABLE
466#if CRYPTOGAMS_ARM_SHA256
472#if CRYPTOPP_ARM_SHA2_AVAILABLE
476#if (CRYPTOPP_POWER8_SHA_AVAILABLE)
483std::string SHA224::AlgorithmProvider()
const
485 return SHA256_AlgorithmProvider();
490 static const word32 s[8] = {
491 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
492 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4};
493 memcpy(state, s,
sizeof(s));
498 static const word32 s[8] = {
499 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
500 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
501 memcpy(state, s,
sizeof(s));
505#if defined(CRYPTOPP_X86_ASM_AVAILABLE)
507ANONYMOUS_NAMESPACE_BEGIN
509void CRYPTOPP_FASTCALL SHA256_HashMultipleBlocks_SSE2(
word32 *state,
const word32 *data,
size_t len)
511 #define LOCALS_SIZE 8*4 + 16*4 + 4*WORD_SZ
512 #define H(i) [BASE+ASM_MOD(1024+7-(i),8)*4]
520 #define Wt(i) BASE+8*4+ASM_MOD(1024+15-(i),16)*4
521 #define Wt_2(i) Wt((i)-2)
522 #define Wt_15(i) Wt((i)-15)
523 #define Wt_7(i) Wt((i)-7)
524 #define K_END [BASE+8*4+16*4+0*WORD_SZ]
525 #define STATE_SAVE [BASE+8*4+16*4+1*WORD_SZ]
526 #define DATA_SAVE [BASE+8*4+16*4+2*WORD_SZ]
527 #define DATA_END [BASE+8*4+16*4+3*WORD_SZ]
528 #define Kt(i) WORD_REG(si)+(i)*4
531#elif defined(__GNUC__)
537#define RA0(i, edx, edi) \
538 AS2( add edx, [Kt(i)] )\
539 AS2( add edx, [Wt(i)] )\
540 AS2( add edx, H(i) )\
542#define RA1(i, edx, edi)
544#define RB0(i, edx, edi)
546#define RB1(i, edx, edi) \
547 AS2( mov AS_REG_7d, [Wt_2(i)] )\
548 AS2( mov edi, [Wt_15(i)])\
549 AS2( mov ebx, AS_REG_7d )\
550 AS2( shr AS_REG_7d, 10 )\
552 AS2( xor AS_REG_7d, ebx )\
554 AS2( xor ebx, AS_REG_7d )\
555 AS2( add ebx, [Wt_7(i)])\
556 AS2( mov AS_REG_7d, edi )\
557 AS2( shr AS_REG_7d, 3 )\
559 AS2( add ebx, [Wt(i)])\
560 AS2( xor AS_REG_7d, edi )\
561 AS2( add edx, [Kt(i)])\
563 AS2( add edx, H(i) )\
564 AS2( xor AS_REG_7d, edi )\
565 AS2( add AS_REG_7d, ebx )\
566 AS2( mov [Wt(i)], AS_REG_7d)\
567 AS2( add edx, AS_REG_7d )\
569#define ROUND(i, r, eax, ecx, edi, edx)\
572 AS2( mov edx, F(i) )\
573 AS2( xor edx, G(i) )\
575 AS2( xor edx, G(i) )\
576 AS2( mov AS_REG_7d, edi )\
578 AS2( ror AS_REG_7d, 25 )\
580 AS2( xor AS_REG_7d, edi )\
582 AS2( xor AS_REG_7d, edi )\
583 AS2( add edx, AS_REG_7d )\
588 AS2( xor ecx, B(i) )\
590 AS2( xor eax, B(i) )\
591 AS2( mov AS_REG_7d, ebx )\
594 AS2( add edx, D(i) )\
595 AS2( mov D(i), edx )\
596 AS2( ror AS_REG_7d, 22 )\
597 AS2( xor AS_REG_7d, ebx )\
599 AS2( xor AS_REG_7d, ebx )\
600 AS2( add eax, AS_REG_7d )\
601 AS2( mov H(i), eax )\
606#define SWAP_COPY(i) \
607 AS2( mov WORD_REG(bx), [WORD_REG(dx)+i*WORD_SZ])\
608 AS1( bswap WORD_REG(bx))\
609 AS2( mov [Wt(i*2+1)], WORD_REG(bx))
611#define SWAP_COPY(i) \
612 AS2( mov WORD_REG(bx), [WORD_REG(dx)+i*WORD_SZ])\
613 AS1( bswap WORD_REG(bx))\
614 AS2( mov [Wt(i)], WORD_REG(bx))
618 #if CRYPTOPP_BOOL_X64
627#elif defined(CRYPTOPP_GENERATE_X64_MASM)
629 SHA256_HashMultipleBlocks_SSE2 PROC FRAME
634 alloc_stack(LOCALS_SIZE+8)
637 lea rsi, [?SHA256_K@
CryptoPP@@3QBIB + 48*4]
643 AS2( lea WORD_REG(si), [SHA256_K+48*4])
645 #
if !defined(_MSC_VER) || (_MSC_VER < 1400)
652 AS2( sub WORD_REG(sp), LOCALS_SIZE)
655 AS2( mov STATE_SAVE, WORD_REG(cx))
656 AS2( mov DATA_SAVE, WORD_REG(dx))
657 AS2( lea WORD_REG(ax), [WORD_REG(di) + WORD_REG(dx)])
658 AS2( mov DATA_END, WORD_REG(ax))
659 AS2( mov K_END, WORD_REG(si))
661#
if CRYPTOPP_SSE2_ASM_AVAILABLE
665 AS1( dec DWORD PTR K_END)
667 AS2( movdqu xmm0, XMMWORD_PTR [WORD_REG(cx)+0*16])
668 AS2( movdqu xmm1, XMMWORD_PTR [WORD_REG(cx)+1*16])
672#
if CRYPTOPP_SSE2_ASM_AVAILABLE
686#
if CRYPTOPP_SSE2_ASM_AVAILABLE
688 AS2( movdqu E(0), xmm1)
689 AS2( movdqu A(0), xmm0)
694 AS2( sub WORD_REG(si), 48*4)
695 SWAP_COPY(0) SWAP_COPY(1) SWAP_COPY(2) SWAP_COPY(3)
696 SWAP_COPY(4) SWAP_COPY(5) SWAP_COPY(6) SWAP_COPY(7)
698 SWAP_COPY(8) SWAP_COPY(9) SWAP_COPY(10) SWAP_COPY(11)
699 SWAP_COPY(12) SWAP_COPY(13) SWAP_COPY(14) SWAP_COPY(15)
706 ROUND(0, 0, eax, ecx, edi, edx)
707 ROUND(1, 0, ecx, eax, edx, edi)
708 ROUND(2, 0, eax, ecx, edi, edx)
709 ROUND(3, 0, ecx, eax, edx, edi)
710 ROUND(4, 0, eax, ecx, edi, edx)
711 ROUND(5, 0, ecx, eax, edx, edi)
712 ROUND(6, 0, eax, ecx, edi, edx)
713 ROUND(7, 0, ecx, eax, edx, edi)
714 ROUND(8, 0, eax, ecx, edi, edx)
715 ROUND(9, 0, ecx, eax, edx, edi)
716 ROUND(10, 0, eax, ecx, edi, edx)
717 ROUND(11, 0, ecx, eax, edx, edi)
718 ROUND(12, 0, eax, ecx, edi, edx)
719 ROUND(13, 0, ecx, eax, edx, edi)
720 ROUND(14, 0, eax, ecx, edi, edx)
721 ROUND(15, 0, ecx, eax, edx, edi)
724 AS2(add WORD_REG(si), 4*16)
725 ROUND(0, 1, eax, ecx, edi, edx)
726 ROUND(1, 1, ecx, eax, edx, edi)
727 ROUND(2, 1, eax, ecx, edi, edx)
728 ROUND(3, 1, ecx, eax, edx, edi)
729 ROUND(4, 1, eax, ecx, edi, edx)
730 ROUND(5, 1, ecx, eax, edx, edi)
731 ROUND(6, 1, eax, ecx, edi, edx)
732 ROUND(7, 1, ecx, eax, edx, edi)
733 ROUND(8, 1, eax, ecx, edi, edx)
734 ROUND(9, 1, ecx, eax, edx, edi)
735 ROUND(10, 1, eax, ecx, edi, edx)
736 ROUND(11, 1, ecx, eax, edx, edi)
737 ROUND(12, 1, eax, ecx, edi, edx)
738 ROUND(13, 1, ecx, eax, edx, edi)
739 ROUND(14, 1, eax, ecx, edi, edx)
740 ROUND(15, 1, ecx, eax, edx, edi)
741 AS2( cmp WORD_REG(si), K_END)
746 AS2( mov WORD_REG(dx), DATA_SAVE)
747 AS2( add WORD_REG(dx), 64)
748 AS2( mov AS_REG_7, STATE_SAVE)
749 AS2( mov DATA_SAVE, WORD_REG(dx))
751#
if CRYPTOPP_SSE2_ASM_AVAILABLE
753 AS2( test DWORD PTR K_END, 1)
756 AS2( movdqu xmm1, XMMWORD_PTR [AS_REG_7+1*16])
757 AS2( movdqu xmm0, XMMWORD_PTR [AS_REG_7+0*16])
758 AS2( paddd xmm1, E(0))
759 AS2( paddd xmm0, A(0))
760 AS2( movdqu [AS_REG_7+1*16], xmm1)
761 AS2( movdqu [AS_REG_7+0*16], xmm0)
762 AS2( cmp WORD_REG(dx), DATA_END)
769#
if CRYPTOPP_SSE2_ASM_AVAILABLE
773 AS2( add [AS_REG_7+0*4], ecx)
774 AS2( add [AS_REG_7+4*4], edi)
778 AS2( add [AS_REG_7+1*4], eax)
779 AS2( add [AS_REG_7+2*4], ebx)
780 AS2( add [AS_REG_7+3*4], ecx)
784 AS2( add [AS_REG_7+5*4], eax)
785 AS2( add [AS_REG_7+6*4], ebx)
786 AS2( add [AS_REG_7+7*4], ecx)
787 AS2( mov ecx, AS_REG_7d)
788 AS2( cmp WORD_REG(dx), DATA_END)
790#
if CRYPTOPP_SSE2_ASM_AVAILABLE
797 #
if !defined(_MSC_VER) || (_MSC_VER < 1400)
801#ifdef CRYPTOPP_GENERATE_X64_MASM
802 add rsp, LOCALS_SIZE+8
808 SHA256_HashMultipleBlocks_SSE2 ENDP
814 :
"c" (state),
"d" (data),
"S" (SHA256_K+48),
"D" (len)
818 :
"memory",
"cc",
"%eax"
820 ,
"%rbx",
"%r8",
"%r10"
826ANONYMOUS_NAMESPACE_END
830#ifndef CRYPTOPP_GENERATE_X64_MASM
832#ifdef CRYPTOPP_X64_MASM_AVAILABLE
834void CRYPTOPP_FASTCALL SHA256_HashMultipleBlocks_SSE2(
word32 *state,
const word32 *data,
size_t len);
838std::string SHA256::AlgorithmProvider()
const
840 return SHA256_AlgorithmProvider();
848#if CRYPTOPP_SHANI_AVAILABLE
855#if CRYPTOGAMS_ARM_SHA256 && 0
858# if defined(CRYPTOPP_LITTLE_ENDIAN)
861 cryptogams_sha256_block_data_order_neon(state, data, 1);
863 cryptogams_sha256_block_data_order_neon(state, data, 1);
869# if defined(CRYPTOPP_LITTLE_ENDIAN)
872 cryptogams_sha256_block_data_order(state, data, 1);
874 cryptogams_sha256_block_data_order(state, data, 1);
879#if CRYPTOPP_ARM_SHA2_AVAILABLE
886#if CRYPTOPP_POWER8_SHA_AVAILABLE
894 SHA256_HashBlock_CXX(state, data);
897size_t SHA256::HashMultipleBlocks(
const word32 *input,
size_t length)
902#if CRYPTOPP_SHANI_AVAILABLE
906 return length & (SHA256::BLOCKSIZE - 1);
909#if CRYPTOPP_SSE2_ASM_AVAILABLE || CRYPTOPP_X64_MASM_AVAILABLE
912 const size_t res = length & (SHA256::BLOCKSIZE - 1);
913 SHA256_HashMultipleBlocks_SSE2(m_state, input, length-res);
917#if CRYPTOGAMS_ARM_SHA256
920 cryptogams_sha256_block_data_order_neon(m_state, input, length / SHA256::BLOCKSIZE);
921 return length & (SHA256::BLOCKSIZE - 1);
925 cryptogams_sha256_block_data_order(m_state, input, length / SHA256::BLOCKSIZE);
926 return length & (SHA256::BLOCKSIZE - 1);
929#if CRYPTOPP_ARM_SHA2_AVAILABLE
933 return length & (SHA256::BLOCKSIZE - 1);
936#if CRYPTOPP_POWER8_SHA_AVAILABLE
940 return length & (SHA256::BLOCKSIZE - 1);
945 word32 *dataBuf = this->DataBuf();
950 SHA256_HashBlock_CXX(m_state, input);
955 SHA256_HashBlock_CXX(m_state, dataBuf);
958 input += SHA256::BLOCKSIZE/
sizeof(
word32);
959 length -= SHA256::BLOCKSIZE;
961 while (length >= SHA256::BLOCKSIZE);
965size_t SHA224::HashMultipleBlocks(
const word32 *input,
size_t length)
970#if CRYPTOPP_SHANI_AVAILABLE
974 return length & (SHA256::BLOCKSIZE - 1);
977#if CRYPTOPP_SSE2_ASM_AVAILABLE || CRYPTOPP_X64_MASM_AVAILABLE
980 const size_t res = length & (SHA256::BLOCKSIZE - 1);
981 SHA256_HashMultipleBlocks_SSE2(m_state, input, length-res);
985#if CRYPTOGAMS_ARM_SHA256
988 cryptogams_sha256_block_data_order_neon(m_state, input, length / SHA256::BLOCKSIZE);
989 return length & (SHA256::BLOCKSIZE - 1);
993 cryptogams_sha256_block_data_order(m_state, input, length / SHA256::BLOCKSIZE);
994 return length & (SHA256::BLOCKSIZE - 1);
997#if CRYPTOPP_ARM_SHA2_AVAILABLE
1001 return length & (SHA256::BLOCKSIZE - 1);
1004#if CRYPTOPP_POWER8_SHA_AVAILABLE
1007 SHA256_HashMultipleBlocks_POWER8(m_state, input, length,
BIG_ENDIAN_ORDER);
1008 return length & (SHA256::BLOCKSIZE - 1);
1013 word32 *dataBuf = this->DataBuf();
1018 SHA256_HashBlock_CXX(m_state, input);
1023 SHA256_HashBlock_CXX(m_state, dataBuf);
1026 input += SHA256::BLOCKSIZE/
sizeof(
word32);
1027 length -= SHA256::BLOCKSIZE;
1029 while (length >= SHA256::BLOCKSIZE);
1035std::string SHA512_AlgorithmProvider()
1037#if CRYPTOPP_SSE2_ASM_AVAILABLE
1041#if CRYPTOGAMS_ARM_SHA512
1047#if (CRYPTOPP_POWER8_SHA_AVAILABLE)
1054std::string SHA384::AlgorithmProvider()
const
1056 return SHA512_AlgorithmProvider();
1059std::string SHA512::AlgorithmProvider()
const
1061 return SHA512_AlgorithmProvider();
1067 W64LIT(0xcbbb9d5dc1059ed8),
W64LIT(0x629a292a367cd507),
1068 W64LIT(0x9159015a3070dd17),
W64LIT(0x152fecd8f70e5939),
1069 W64LIT(0x67332667ffc00b31),
W64LIT(0x8eb44a8768581511),
1070 W64LIT(0xdb0c2e0d64f98fa7),
W64LIT(0x47b5481dbefa4fa4)};
1071 memcpy(state, s,
sizeof(s));
1077 W64LIT(0x6a09e667f3bcc908),
W64LIT(0xbb67ae8584caa73b),
1078 W64LIT(0x3c6ef372fe94f82b),
W64LIT(0xa54ff53a5f1d36f1),
1079 W64LIT(0x510e527fade682d1),
W64LIT(0x9b05688c2b3e6c1f),
1080 W64LIT(0x1f83d9abfb41bd6b),
W64LIT(0x5be0cd19137e2179)};
1081 memcpy(state, s,
sizeof(s));
1084#if CRYPTOPP_SSE2_ASM_AVAILABLE && (CRYPTOPP_BOOL_X86)
1086ANONYMOUS_NAMESPACE_BEGIN
1094CRYPTOPP_NOINLINE CRYPTOPP_NAKED
1095void CRYPTOPP_FASTCALL SHA512_HashBlock_SSE2(
word64 *state,
const word64 *data)
1098 __asm__ __volatile__
1107 AS2( lea ebx, SHA512_K)
1111 AS2( and esp, 0xfffffff0)
1112 AS2( sub esp, 27*16)
1116 AS2( lea edi, [esp+4+8*8])
1117 AS2( lea esi, [esp+4+20*8+8])
1119 AS2( movdqu xmm0, [ecx+0*16])
1120 AS2( movdq2q mm4, xmm0)
1121 AS2( movdqu [edi+0*16], xmm0)
1122 AS2( movdqu xmm0, [ecx+1*16])
1123 AS2( movdqu [edi+1*16], xmm0)
1124 AS2( movdqu xmm0, [ecx+2*16])
1125 AS2( movdq2q mm5, xmm0)
1126 AS2( movdqu [edi+2*16], xmm0)
1127 AS2( movdqu xmm0, [ecx+3*16])
1128 AS2( movdqu [edi+3*16], xmm0)
1131#define SSE2_S0_S1(r, a, b, c) \
1135 AS2( psllq mm6, 64-c)\
1136 AS2( pxor mm7, mm6)\
1139 AS2( psllq mm6, c-b)\
1140 AS2( pxor mm7, mm6)\
1143 AS2( psllq mm6, b-a)\
1146#define SSE2_s0(r, a, b, c) \
1147 AS2( movdqu xmm6, r)\
1149 AS2( movdqu xmm7, r)\
1150 AS2( psllq xmm6, 64-c)\
1151 AS2( pxor xmm7, xmm6)\
1156 AS2( psllq xmm6, c-a)\
1159#define SSE2_s1(r, a, b, c) \
1160 AS2( movdqu xmm6, r)\
1162 AS2( movdqu xmm7, r)\
1163 AS2( psllq xmm6, 64-c)\
1164 AS2( pxor xmm7, xmm6)\
1167 AS2( psllq xmm6, c-b)\
1168 AS2( pxor xmm7, xmm6)\
1174 AS2( paddq mm0, [edi+7*8])
1175 AS2( movq mm2, [edi+5*8])
1176 AS2( movq mm3, [edi+6*8])
1179 SSE2_S0_S1(mm5,14,18,41)
1181 AS2( paddq mm0, mm2)
1182 AS2( paddq mm5, mm0)
1183 AS2( movq mm2, [edi+1*8])
1186 AS2( pand mm2, [edi+2*8])
1189 AS2( paddq mm1, mm5)
1190 AS2( paddq mm5, [edi+3*8])
1191 AS2( movq [edi+3*8], mm5)
1192 AS2( movq [edi+11*8], mm5)
1193 SSE2_S0_S1(mm4,28,34,39)
1194 AS2( paddq mm4, mm1)
1195 AS2( movq [edi-8], mm4)
1196 AS2( movq [edi+7*8], mm4)
1201 AS2( movq mm0, [edx+eax*8])
1202 AS2( movq [esi+eax*8], mm0)
1203 AS2( movq [esi+eax*8+16*8], mm0)
1204 AS2( paddq mm0, [ebx+eax*8])
1205 ASC( call, SHA512_Round)
1216 AS2( movdqu xmm0, [esi+(16-2)*8])
1219 AS2( movdqu xmm3, [esi])
1220 AS2( paddq xmm3, [esi+(16-7)*8])
1221 AS2( movdqu xmm2, [esi+(16-15)*8])
1222 SSE2_s1(xmm0, 6, 19, 61)
1223 AS2( paddq xmm0, xmm3)
1224 SSE2_s0(xmm2, 1, 7, 8)
1225 AS2( paddq xmm0, xmm2)
1226 AS2( movdq2q mm0, xmm0)
1227 AS2( movhlps xmm1, xmm0)
1228 AS2( paddq mm0, [ebx+eax*8])
1229 AS2( movlps [esi], xmm0)
1230 AS2( movlps [esi+8], xmm1)
1231 AS2( movlps [esi+8*16], xmm0)
1232 AS2( movlps [esi+8*17], xmm1)
1234 ASC( call, SHA512_Round)
1236 AS2( movdq2q mm0, xmm1)
1237 AS2( paddq mm0, [ebx+eax*8+8])
1238 ASC( call, SHA512_Round)
1248 AS2( lea esi, [esp+4+20*8+8+esi*8])
1253#define SSE2_CombineState(i) \
1254 AS2( movdqu xmm0, [edi+i*16])\
1255 AS2( paddq xmm0, [ecx+i*16])\
1256 AS2( movdqu [ecx+i*16], xmm0)
1258 SSE2_CombineState(0)
1259 SSE2_CombineState(1)
1260 SSE2_CombineState(2)
1261 SSE2_CombineState(3)
1266#
if defined(__GNUC__)
1270 :
"a" (SHA512_K),
"c" (state),
"d" (data)
1271 :
"%esi",
"%edi",
"memory",
"cc"
1281ANONYMOUS_NAMESPACE_END
1285ANONYMOUS_NAMESPACE_BEGIN
1287#define a(i) T[(0-i)&7]
1288#define b(i) T[(1-i)&7]
1289#define c(i) T[(2-i)&7]
1290#define d(i) T[(3-i)&7]
1291#define e(i) T[(4-i)&7]
1292#define f(i) T[(5-i)&7]
1293#define g(i) T[(6-i)&7]
1294#define h(i) T[(7-i)&7]
1296#define blk0(i) (W[i]=data[i])
1297#define blk2(i) (W[i&15]+=s1(W[(i-2)&15])+W[(i-7)&15]+s0(W[(i-15)&15]))
1299#define Ch(x,y,z) (z^(x&(y^z)))
1300#define Maj(x,y,z) (y^((x^y)&(y^z)))
1302#define s0(x) (rotrConstant<1>(x)^rotrConstant<8>(x)^(x>>7))
1303#define s1(x) (rotrConstant<19>(x)^rotrConstant<61>(x)^(x>>6))
1304#define S0(x) (rotrConstant<28>(x)^rotrConstant<34>(x)^rotrConstant<39>(x))
1305#define S1(x) (rotrConstant<14>(x)^rotrConstant<18>(x)^rotrConstant<41>(x))
1307#define R(i) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+SHA512_K[i+j]+\
1308 (j?blk2(i):blk0(i));d(i)+=h(i);h(i)+=S0(a(i))+Maj(a(i),b(i),c(i));
1310void SHA512_HashBlock_CXX(
word64 *state,
const word64 *data)
1318 std::memcpy(T, state,
sizeof(T));
1321 for (
unsigned int j=0; j<80; j+=16)
1323 R( 0); R( 1); R( 2); R( 3);
1324 R( 4); R( 5); R( 6); R( 7);
1325 R( 8); R( 9); R(10); R(11);
1326 R(12); R(13); R(14); R(15);
1339ANONYMOUS_NAMESPACE_END
1346#if CRYPTOPP_SSE2_ASM_AVAILABLE && (CRYPTOPP_BOOL_X86)
1349 SHA512_HashBlock_SSE2(state, data);
1353#if CRYPTOGAMS_ARM_SHA512
1356# if (CRYPTOPP_LITTLE_ENDIAN)
1359 cryptogams_sha512_block_data_order_neon(state, dataBuf, 1);
1361 cryptogams_sha512_block_data_order_neon(state, data, 1);
1367# if (CRYPTOPP_LITTLE_ENDIAN)
1370 cryptogams_sha512_block_data_order(state, dataBuf, 1);
1372 cryptogams_sha512_block_data_order(state, data, 1);
1377#if CRYPTOPP_POWER8_SHA_AVAILABLE
1380 SHA512_HashMultipleBlocks_POWER8(state, data, SHA512::BLOCKSIZE,
BIG_ENDIAN_ORDER);
1385 SHA512_HashBlock_CXX(state, data);
Fixed size stack-based SecBlock with 16-byte alignment.
static void Transform(HashWordType *digest, const HashWordType *data)
Operate the hash.
static void InitState(HashWordType *state)
Initialize state array.
static void InitState(HashWordType *state)
Initialize state array.
static void InitState(HashWordType *state)
Initialize state array.
static void Transform(HashWordType *digest, const HashWordType *data)
Operate the hash.
static void InitState(HashWordType *state)
Initialize state array.
static void Transform(HashWordType *digest, const HashWordType *data)
Operate the hash.
static void InitState(HashWordType *state)
Initialize state array.
Library configuration file.
#define CRYPTOPP_BOOL_X86
32-bit x86 platform
#define CRYPTOPP_BOOL_X64
32-bit x86 platform
#define W64LIT(x)
Declare an unsigned word64.
unsigned int word32
32-bit unsigned datatype
unsigned long long word64
64-bit unsigned datatype
Functions for CPU features and intrinsics.
ByteOrder
Provides the byte ordering.
@ LITTLE_ENDIAN_ORDER
byte order is little-endian
@ BIG_ENDIAN_ORDER
byte order is big-endian
Utility functions for the Crypto++ library.
byte ByteReverse(byte value)
Reverses bytes in a 8-bit value.
bool NativeByteOrderIs(ByteOrder order)
Determines whether order follows native byte ordering.
Crypto++ library namespace.
Classes and functions for secure memory allocations.
Classes for SHA-1 and SHA-2 family of message digests.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.