Crypto++  6.1
Free C++ class library of cryptographic schemes
sha-simd.cpp
1 // sha-simd.cpp - written and placed in the public domain by
2 // Jeffrey Walton, Uri Blumenthal and Marcel Raad.
3 //
4 // This source file uses intrinsics to gain access to SHA-NI and
5 // ARMv8a SHA instructions. A separate source file is needed
6 // because additional CXXFLAGS are required to enable the
7 // appropriate instructions sets in some build configurations.
8 
9 #include "pch.h"
10 #include "config.h"
11 #include "sha.h"
12 #include "misc.h"
13 
14 #if (CRYPTOPP_SHANI_AVAILABLE)
15 # include <nmmintrin.h>
16 # include <immintrin.h>
17 #endif
18 
19 // Use ARMv8 rather than NEON due to compiler inconsistencies
20 #if (CRYPTOPP_ARM_SHA_AVAILABLE)
21 # include <arm_neon.h>
22 #endif
23 
24 // Can't use CRYPTOPP_ARM_XXX_AVAILABLE because too many
25 // compilers don't follow ACLE conventions for the include.
26 #if defined(CRYPTOPP_ARM_ACLE_AVAILABLE)
27 # include <stdint.h>
28 # include <arm_acle.h>
29 #endif
30 
31 #if CRYPTOPP_POWER8_SHA_AVAILABLE
32 # include "ppc-simd.h"
33 #endif
34 
35 #ifdef CRYPTOPP_GNU_STYLE_INLINE_ASSEMBLY
36 # include <signal.h>
37 # include <setjmp.h>
38 #endif
39 
40 #ifndef EXCEPTION_EXECUTE_HANDLER
41 # define EXCEPTION_EXECUTE_HANDLER 1
42 #endif
43 
44 // Clang __m128i casts
45 #define M128_CAST(x) ((__m128i *)(void *)(x))
46 #define CONST_M128_CAST(x) ((const __m128i *)(const void *)(x))
47 
48 NAMESPACE_BEGIN(CryptoPP)
49 
50 // ***************** SIGILL probes ********************
51 
52 #ifdef CRYPTOPP_GNU_STYLE_INLINE_ASSEMBLY
53 extern "C" {
54  typedef void (*SigHandler)(int);
55 
56  static jmp_buf s_jmpSIGILL;
57  static void SigIllHandler(int)
58  {
59  longjmp(s_jmpSIGILL, 1);
60  }
61 };
62 #endif // Not CRYPTOPP_MS_STYLE_INLINE_ASSEMBLY
63 
64 #if (CRYPTOPP_BOOL_ARM32 || CRYPTOPP_BOOL_ARM64)
65 bool CPU_ProbeSHA1()
66 {
67 #if defined(CRYPTOPP_NO_CPU_FEATURE_PROBES)
68  return false;
69 #elif (CRYPTOPP_ARM_SHA_AVAILABLE)
70 # if defined(CRYPTOPP_MS_STYLE_INLINE_ASSEMBLY)
71  volatile bool result = true;
72  __try
73  {
74  uint32x4_t data1 = {1,2,3,4}, data2 = {5,6,7,8}, data3 = {9,10,11,12};
75 
76  uint32x4_t r1 = vsha1cq_u32 (data1, 0, data2);
77  uint32x4_t r2 = vsha1mq_u32 (data1, 0, data2);
78  uint32x4_t r3 = vsha1pq_u32 (data1, 0, data2);
79  uint32x4_t r4 = vsha1su0q_u32 (data1, data2, data3);
80  uint32x4_t r5 = vsha1su1q_u32 (data1, data2);
81 
82  result = !!(vgetq_lane_u32(r1,0) | vgetq_lane_u32(r2,1) | vgetq_lane_u32(r3,2) | vgetq_lane_u32(r4,3) | vgetq_lane_u32(r5,0));
83  }
84  __except (EXCEPTION_EXECUTE_HANDLER)
85  {
86  return false;
87  }
88  return result;
89 # else
90 
91  // longjmp and clobber warnings. Volatile is required.
92  // http://github.com/weidai11/cryptopp/issues/24 and http://stackoverflow.com/q/7721854
93  volatile bool result = true;
94 
95  volatile SigHandler oldHandler = signal(SIGILL, SigIllHandler);
96  if (oldHandler == SIG_ERR)
97  return false;
98 
99  volatile sigset_t oldMask;
100  if (sigprocmask(0, NULLPTR, (sigset_t*)&oldMask))
101  return false;
102 
103  if (setjmp(s_jmpSIGILL))
104  result = false;
105  else
106  {
107  uint32x4_t data1 = {1,2,3,4}, data2 = {5,6,7,8}, data3 = {9,10,11,12};
108 
109  uint32x4_t r1 = vsha1cq_u32 (data1, 0, data2);
110  uint32x4_t r2 = vsha1mq_u32 (data1, 0, data2);
111  uint32x4_t r3 = vsha1pq_u32 (data1, 0, data2);
112  uint32x4_t r4 = vsha1su0q_u32 (data1, data2, data3);
113  uint32x4_t r5 = vsha1su1q_u32 (data1, data2);
114 
115  result = !!(vgetq_lane_u32(r1,0) | vgetq_lane_u32(r2,1) | vgetq_lane_u32(r3,2) | vgetq_lane_u32(r4,3) | vgetq_lane_u32(r5,0));
116  }
117 
118  sigprocmask(SIG_SETMASK, (sigset_t*)&oldMask, NULLPTR);
119  signal(SIGILL, oldHandler);
120  return result;
121 # endif
122 #else
123  return false;
124 #endif // CRYPTOPP_ARM_SHA_AVAILABLE
125 }
126 
127 bool CPU_ProbeSHA2()
128 {
129 #if defined(CRYPTOPP_NO_CPU_FEATURE_PROBES)
130  return false;
131 #elif (CRYPTOPP_ARM_SHA_AVAILABLE)
132 # if defined(CRYPTOPP_MS_STYLE_INLINE_ASSEMBLY)
133  volatile bool result = true;
134  __try
135  {
136  uint32x4_t data1 = {1,2,3,4}, data2 = {5,6,7,8}, data3 = {9,10,11,12};
137 
138  uint32x4_t r1 = vsha256hq_u32 (data1, data2, data3);
139  uint32x4_t r2 = vsha256h2q_u32 (data1, data2, data3);
140  uint32x4_t r3 = vsha256su0q_u32 (data1, data2);
141  uint32x4_t r4 = vsha256su1q_u32 (data1, data2, data3);
142 
143  result = !!(vgetq_lane_u32(r1,0) | vgetq_lane_u32(r2,1) | vgetq_lane_u32(r3,2) | vgetq_lane_u32(r4,3));
144  }
145  __except (EXCEPTION_EXECUTE_HANDLER)
146  {
147  return false;
148  }
149  return result;
150 #else
151 
152  // longjmp and clobber warnings. Volatile is required.
153  // http://github.com/weidai11/cryptopp/issues/24 and http://stackoverflow.com/q/7721854
154  volatile bool result = true;
155 
156  volatile SigHandler oldHandler = signal(SIGILL, SigIllHandler);
157  if (oldHandler == SIG_ERR)
158  return false;
159 
160  volatile sigset_t oldMask;
161  if (sigprocmask(0, NULLPTR, (sigset_t*)&oldMask))
162  return false;
163 
164  if (setjmp(s_jmpSIGILL))
165  result = false;
166  else
167  {
168  uint32x4_t data1 = {1,2,3,4}, data2 = {5,6,7,8}, data3 = {9,10,11,12};
169 
170  uint32x4_t r1 = vsha256hq_u32 (data1, data2, data3);
171  uint32x4_t r2 = vsha256h2q_u32 (data1, data2, data3);
172  uint32x4_t r3 = vsha256su0q_u32 (data1, data2);
173  uint32x4_t r4 = vsha256su1q_u32 (data1, data2, data3);
174 
175  result = !!(vgetq_lane_u32(r1,0) | vgetq_lane_u32(r2,1) | vgetq_lane_u32(r3,2) | vgetq_lane_u32(r4,3));
176  }
177 
178  sigprocmask(SIG_SETMASK, (sigset_t*)&oldMask, NULLPTR);
179  signal(SIGILL, oldHandler);
180  return result;
181 # endif
182 #else
183  return false;
184 #endif // CRYPTOPP_ARM_SHA_AVAILABLE
185 }
186 #endif // ARM32 or ARM64
187 
188 // ***************** Intel x86 SHA ********************
189 
190 // provided by sha.cpp
191 extern const word32 SHA256_K[64];
192 
193 ///////////////////////////////////
194 // start of Walton/Gulley's code //
195 ///////////////////////////////////
196 
197 #if CRYPTOPP_SHANI_AVAILABLE
198 // Based on http://software.intel.com/en-us/articles/intel-sha-extensions and code by Sean Gulley.
199 void SHA1_HashMultipleBlocks_SHANI(word32 *state, const word32 *data, size_t length, ByteOrder order)
200 {
201  CRYPTOPP_ASSERT(state);
202  CRYPTOPP_ASSERT(data);
203  CRYPTOPP_ASSERT(length >= SHA1::BLOCKSIZE);
204 
205  __m128i ABCD, ABCD_SAVE, E0, E0_SAVE, E1;
206  __m128i MASK, MSG0, MSG1, MSG2, MSG3;
207 
208  // Load initial values
209  ABCD = _mm_loadu_si128(CONST_M128_CAST(state));
210  E0 = _mm_set_epi32(state[4], 0, 0, 0);
211  ABCD = _mm_shuffle_epi32(ABCD, 0x1B);
212 
213  // IA-32 SHA is little endian, SHA::Transform is big endian,
214  // and SHA::HashMultipleBlocks can be either. ByteOrder
215  // allows us to avoid extra endian reversals. It saves 1.0 cpb.
216  MASK = order == BIG_ENDIAN_ORDER ? // Data arrangement
217  _mm_set_epi8(0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15) :
218  _mm_set_epi8(3,2,1,0, 7,6,5,4, 11,10,9,8, 15,14,13,12) ;
219 
220  while (length >= SHA1::BLOCKSIZE)
221  {
222  // Save current hash
223  ABCD_SAVE = ABCD;
224  E0_SAVE = E0;
225 
226  // Rounds 0-3
227  MSG0 = _mm_loadu_si128(CONST_M128_CAST(data+0));
228  MSG0 = _mm_shuffle_epi8(MSG0, MASK);
229  E0 = _mm_add_epi32(E0, MSG0);
230  E1 = ABCD;
231  ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 0);
232 
233  // Rounds 4-7
234  MSG1 = _mm_loadu_si128(CONST_M128_CAST(data+4));
235  MSG1 = _mm_shuffle_epi8(MSG1, MASK);
236  E1 = _mm_sha1nexte_epu32(E1, MSG1);
237  E0 = ABCD;
238  ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 0);
239  MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1);
240 
241  // Rounds 8-11
242  MSG2 = _mm_loadu_si128(CONST_M128_CAST(data+8));
243  MSG2 = _mm_shuffle_epi8(MSG2, MASK);
244  E0 = _mm_sha1nexte_epu32(E0, MSG2);
245  E1 = ABCD;
246  ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 0);
247  MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2);
248  MSG0 = _mm_xor_si128(MSG0, MSG2);
249 
250  // Rounds 12-15
251  MSG3 = _mm_loadu_si128(CONST_M128_CAST(data+12));
252  MSG3 = _mm_shuffle_epi8(MSG3, MASK);
253  E1 = _mm_sha1nexte_epu32(E1, MSG3);
254  E0 = ABCD;
255  MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3);
256  ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 0);
257  MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3);
258  MSG1 = _mm_xor_si128(MSG1, MSG3);
259 
260  // Rounds 16-19
261  E0 = _mm_sha1nexte_epu32(E0, MSG0);
262  E1 = ABCD;
263  MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0);
264  ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 0);
265  MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0);
266  MSG2 = _mm_xor_si128(MSG2, MSG0);
267 
268  // Rounds 20-23
269  E1 = _mm_sha1nexte_epu32(E1, MSG1);
270  E0 = ABCD;
271  MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1);
272  ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 1);
273  MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1);
274  MSG3 = _mm_xor_si128(MSG3, MSG1);
275 
276  // Rounds 24-27
277  E0 = _mm_sha1nexte_epu32(E0, MSG2);
278  E1 = ABCD;
279  MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2);
280  ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 1);
281  MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2);
282  MSG0 = _mm_xor_si128(MSG0, MSG2);
283 
284  // Rounds 28-31
285  E1 = _mm_sha1nexte_epu32(E1, MSG3);
286  E0 = ABCD;
287  MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3);
288  ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 1);
289  MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3);
290  MSG1 = _mm_xor_si128(MSG1, MSG3);
291 
292  // Rounds 32-35
293  E0 = _mm_sha1nexte_epu32(E0, MSG0);
294  E1 = ABCD;
295  MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0);
296  ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 1);
297  MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0);
298  MSG2 = _mm_xor_si128(MSG2, MSG0);
299 
300  // Rounds 36-39
301  E1 = _mm_sha1nexte_epu32(E1, MSG1);
302  E0 = ABCD;
303  MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1);
304  ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 1);
305  MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1);
306  MSG3 = _mm_xor_si128(MSG3, MSG1);
307 
308  // Rounds 40-43
309  E0 = _mm_sha1nexte_epu32(E0, MSG2);
310  E1 = ABCD;
311  MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2);
312  ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 2);
313  MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2);
314  MSG0 = _mm_xor_si128(MSG0, MSG2);
315 
316  // Rounds 44-47
317  E1 = _mm_sha1nexte_epu32(E1, MSG3);
318  E0 = ABCD;
319  MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3);
320  ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 2);
321  MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3);
322  MSG1 = _mm_xor_si128(MSG1, MSG3);
323 
324  // Rounds 48-51
325  E0 = _mm_sha1nexte_epu32(E0, MSG0);
326  E1 = ABCD;
327  MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0);
328  ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 2);
329  MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0);
330  MSG2 = _mm_xor_si128(MSG2, MSG0);
331 
332  // Rounds 52-55
333  E1 = _mm_sha1nexte_epu32(E1, MSG1);
334  E0 = ABCD;
335  MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1);
336  ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 2);
337  MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1);
338  MSG3 = _mm_xor_si128(MSG3, MSG1);
339 
340  // Rounds 56-59
341  E0 = _mm_sha1nexte_epu32(E0, MSG2);
342  E1 = ABCD;
343  MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2);
344  ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 2);
345  MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2);
346  MSG0 = _mm_xor_si128(MSG0, MSG2);
347 
348  // Rounds 60-63
349  E1 = _mm_sha1nexte_epu32(E1, MSG3);
350  E0 = ABCD;
351  MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3);
352  ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 3);
353  MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3);
354  MSG1 = _mm_xor_si128(MSG1, MSG3);
355 
356  // Rounds 64-67
357  E0 = _mm_sha1nexte_epu32(E0, MSG0);
358  E1 = ABCD;
359  MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0);
360  ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 3);
361  MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0);
362  MSG2 = _mm_xor_si128(MSG2, MSG0);
363 
364  // Rounds 68-71
365  E1 = _mm_sha1nexte_epu32(E1, MSG1);
366  E0 = ABCD;
367  MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1);
368  ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 3);
369  MSG3 = _mm_xor_si128(MSG3, MSG1);
370 
371  // Rounds 72-75
372  E0 = _mm_sha1nexte_epu32(E0, MSG2);
373  E1 = ABCD;
374  MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2);
375  ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 3);
376 
377  // Rounds 76-79
378  E1 = _mm_sha1nexte_epu32(E1, MSG3);
379  E0 = ABCD;
380  ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 3);
381 
382  // Add values back to state
383  E0 = _mm_sha1nexte_epu32(E0, E0_SAVE);
384  ABCD = _mm_add_epi32(ABCD, ABCD_SAVE);
385 
386  data += SHA1::BLOCKSIZE/sizeof(word32);
387  length -= SHA1::BLOCKSIZE;
388  }
389 
390  // Save state
391  ABCD = _mm_shuffle_epi32(ABCD, 0x1B);
392  _mm_storeu_si128(M128_CAST(state), ABCD);
393  state[4] = _mm_extract_epi32(E0, 3);
394 }
395 
396 // Based on http://software.intel.com/en-us/articles/intel-sha-extensions and code by Sean Gulley.
397 void SHA256_HashMultipleBlocks_SHANI(word32 *state, const word32 *data, size_t length, ByteOrder order)
398 {
399  CRYPTOPP_ASSERT(state);
400  CRYPTOPP_ASSERT(data);
401  CRYPTOPP_ASSERT(length >= SHA256::BLOCKSIZE);
402 
403  __m128i STATE0, STATE1;
404  __m128i MSG, TMP, MASK;
405  __m128i TMSG0, TMSG1, TMSG2, TMSG3;
406  __m128i ABEF_SAVE, CDGH_SAVE;
407 
408  // Load initial values
409  TMP = _mm_loadu_si128(M128_CAST(&state[0]));
410  STATE1 = _mm_loadu_si128(M128_CAST(&state[4]));
411 
412  // IA-32 SHA is little endian, SHA::Transform is big endian,
413  // and SHA::HashMultipleBlocks can be either. ByteOrder
414  // allows us to avoid extra endian reversals. It saves 1.0 cpb.
415  MASK = order == BIG_ENDIAN_ORDER ? // Data arrangement
416  _mm_set_epi8(12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3) :
417  _mm_set_epi8(15,14,13,12, 11,10,9,8, 7,6,5,4, 3,2,1,0) ;
418 
419  TMP = _mm_shuffle_epi32(TMP, 0xB1); // CDAB
420  STATE1 = _mm_shuffle_epi32(STATE1, 0x1B); // EFGH
421  STATE0 = _mm_alignr_epi8(TMP, STATE1, 8); // ABEF
422  STATE1 = _mm_blend_epi16(STATE1, TMP, 0xF0); // CDGH
423 
424  while (length >= SHA256::BLOCKSIZE)
425  {
426  // Save current hash
427  ABEF_SAVE = STATE0;
428  CDGH_SAVE = STATE1;
429 
430  // Rounds 0-3
431  MSG = _mm_loadu_si128(CONST_M128_CAST(data+0));
432  TMSG0 = _mm_shuffle_epi8(MSG, MASK);
433  MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(W64LIT(0xE9B5DBA5B5C0FBCF), W64LIT(0x71374491428A2F98)));
434  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
435  MSG = _mm_shuffle_epi32(MSG, 0x0E);
436  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
437 
438  // Rounds 4-7
439  TMSG1 = _mm_loadu_si128(CONST_M128_CAST(data+4));
440  TMSG1 = _mm_shuffle_epi8(TMSG1, MASK);
441  MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(W64LIT(0xAB1C5ED5923F82A4), W64LIT(0x59F111F13956C25B)));
442  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
443  MSG = _mm_shuffle_epi32(MSG, 0x0E);
444  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
445  TMSG0 = _mm_sha256msg1_epu32(TMSG0, TMSG1);
446 
447  // Rounds 8-11
448  TMSG2 = _mm_loadu_si128(CONST_M128_CAST(data+8));
449  TMSG2 = _mm_shuffle_epi8(TMSG2, MASK);
450  MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(W64LIT(0x550C7DC3243185BE), W64LIT(0x12835B01D807AA98)));
451  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
452  MSG = _mm_shuffle_epi32(MSG, 0x0E);
453  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
454  TMSG1 = _mm_sha256msg1_epu32(TMSG1, TMSG2);
455 
456  // Rounds 12-15
457  TMSG3 = _mm_loadu_si128(CONST_M128_CAST(data+12));
458  TMSG3 = _mm_shuffle_epi8(TMSG3, MASK);
459  MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(W64LIT(0xC19BF1749BDC06A7), W64LIT(0x80DEB1FE72BE5D74)));
460  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
461  TMP = _mm_alignr_epi8(TMSG3, TMSG2, 4);
462  TMSG0 = _mm_add_epi32(TMSG0, TMP);
463  TMSG0 = _mm_sha256msg2_epu32(TMSG0, TMSG3);
464  MSG = _mm_shuffle_epi32(MSG, 0x0E);
465  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
466  TMSG2 = _mm_sha256msg1_epu32(TMSG2, TMSG3);
467 
468  // Rounds 16-19
469  MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(W64LIT(0x240CA1CC0FC19DC6), W64LIT(0xEFBE4786E49B69C1)));
470  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
471  TMP = _mm_alignr_epi8(TMSG0, TMSG3, 4);
472  TMSG1 = _mm_add_epi32(TMSG1, TMP);
473  TMSG1 = _mm_sha256msg2_epu32(TMSG1, TMSG0);
474  MSG = _mm_shuffle_epi32(MSG, 0x0E);
475  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
476  TMSG3 = _mm_sha256msg1_epu32(TMSG3, TMSG0);
477 
478  // Rounds 20-23
479  MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(W64LIT(0x76F988DA5CB0A9DC), W64LIT(0x4A7484AA2DE92C6F)));
480  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
481  TMP = _mm_alignr_epi8(TMSG1, TMSG0, 4);
482  TMSG2 = _mm_add_epi32(TMSG2, TMP);
483  TMSG2 = _mm_sha256msg2_epu32(TMSG2, TMSG1);
484  MSG = _mm_shuffle_epi32(MSG, 0x0E);
485  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
486  TMSG0 = _mm_sha256msg1_epu32(TMSG0, TMSG1);
487 
488  // Rounds 24-27
489  MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(W64LIT(0xBF597FC7B00327C8), W64LIT(0xA831C66D983E5152)));
490  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
491  TMP = _mm_alignr_epi8(TMSG2, TMSG1, 4);
492  TMSG3 = _mm_add_epi32(TMSG3, TMP);
493  TMSG3 = _mm_sha256msg2_epu32(TMSG3, TMSG2);
494  MSG = _mm_shuffle_epi32(MSG, 0x0E);
495  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
496  TMSG1 = _mm_sha256msg1_epu32(TMSG1, TMSG2);
497 
498  // Rounds 28-31
499  MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(W64LIT(0x1429296706CA6351), W64LIT(0xD5A79147C6E00BF3)));
500  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
501  TMP = _mm_alignr_epi8(TMSG3, TMSG2, 4);
502  TMSG0 = _mm_add_epi32(TMSG0, TMP);
503  TMSG0 = _mm_sha256msg2_epu32(TMSG0, TMSG3);
504  MSG = _mm_shuffle_epi32(MSG, 0x0E);
505  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
506  TMSG2 = _mm_sha256msg1_epu32(TMSG2, TMSG3);
507 
508  // Rounds 32-35
509  MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(W64LIT(0x53380D134D2C6DFC), W64LIT(0x2E1B213827B70A85)));
510  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
511  TMP = _mm_alignr_epi8(TMSG0, TMSG3, 4);
512  TMSG1 = _mm_add_epi32(TMSG1, TMP);
513  TMSG1 = _mm_sha256msg2_epu32(TMSG1, TMSG0);
514  MSG = _mm_shuffle_epi32(MSG, 0x0E);
515  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
516  TMSG3 = _mm_sha256msg1_epu32(TMSG3, TMSG0);
517 
518  // Rounds 36-39
519  MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(W64LIT(0x92722C8581C2C92E), W64LIT(0x766A0ABB650A7354)));
520  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
521  TMP = _mm_alignr_epi8(TMSG1, TMSG0, 4);
522  TMSG2 = _mm_add_epi32(TMSG2, TMP);
523  TMSG2 = _mm_sha256msg2_epu32(TMSG2, TMSG1);
524  MSG = _mm_shuffle_epi32(MSG, 0x0E);
525  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
526  TMSG0 = _mm_sha256msg1_epu32(TMSG0, TMSG1);
527 
528  // Rounds 40-43
529  MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(W64LIT(0xC76C51A3C24B8B70), W64LIT(0xA81A664BA2BFE8A1)));
530  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
531  TMP = _mm_alignr_epi8(TMSG2, TMSG1, 4);
532  TMSG3 = _mm_add_epi32(TMSG3, TMP);
533  TMSG3 = _mm_sha256msg2_epu32(TMSG3, TMSG2);
534  MSG = _mm_shuffle_epi32(MSG, 0x0E);
535  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
536  TMSG1 = _mm_sha256msg1_epu32(TMSG1, TMSG2);
537 
538  // Rounds 44-47
539  MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(W64LIT(0x106AA070F40E3585), W64LIT(0xD6990624D192E819)));
540  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
541  TMP = _mm_alignr_epi8(TMSG3, TMSG2, 4);
542  TMSG0 = _mm_add_epi32(TMSG0, TMP);
543  TMSG0 = _mm_sha256msg2_epu32(TMSG0, TMSG3);
544  MSG = _mm_shuffle_epi32(MSG, 0x0E);
545  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
546  TMSG2 = _mm_sha256msg1_epu32(TMSG2, TMSG3);
547 
548  // Rounds 48-51
549  MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(W64LIT(0x34B0BCB52748774C), W64LIT(0x1E376C0819A4C116)));
550  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
551  TMP = _mm_alignr_epi8(TMSG0, TMSG3, 4);
552  TMSG1 = _mm_add_epi32(TMSG1, TMP);
553  TMSG1 = _mm_sha256msg2_epu32(TMSG1, TMSG0);
554  MSG = _mm_shuffle_epi32(MSG, 0x0E);
555  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
556  TMSG3 = _mm_sha256msg1_epu32(TMSG3, TMSG0);
557 
558  // Rounds 52-55
559  MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(W64LIT(0x682E6FF35B9CCA4F), W64LIT(0x4ED8AA4A391C0CB3)));
560  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
561  TMP = _mm_alignr_epi8(TMSG1, TMSG0, 4);
562  TMSG2 = _mm_add_epi32(TMSG2, TMP);
563  TMSG2 = _mm_sha256msg2_epu32(TMSG2, TMSG1);
564  MSG = _mm_shuffle_epi32(MSG, 0x0E);
565  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
566 
567  // Rounds 56-59
568  MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(W64LIT(0x8CC7020884C87814), W64LIT(0x78A5636F748F82EE)));
569  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
570  TMP = _mm_alignr_epi8(TMSG2, TMSG1, 4);
571  TMSG3 = _mm_add_epi32(TMSG3, TMP);
572  TMSG3 = _mm_sha256msg2_epu32(TMSG3, TMSG2);
573  MSG = _mm_shuffle_epi32(MSG, 0x0E);
574  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
575 
576  // Rounds 60-63
577  MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(W64LIT(0xC67178F2BEF9A3F7), W64LIT(0xA4506CEB90BEFFFA)));
578  STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
579  MSG = _mm_shuffle_epi32(MSG, 0x0E);
580  STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
581 
582  // Add values back to state
583  STATE0 = _mm_add_epi32(STATE0, ABEF_SAVE);
584  STATE1 = _mm_add_epi32(STATE1, CDGH_SAVE);
585 
586  data += SHA256::BLOCKSIZE/sizeof(word32);
587  length -= SHA256::BLOCKSIZE;
588  }
589 
590  TMP = _mm_shuffle_epi32(STATE0, 0x1B); // FEBA
591  STATE1 = _mm_shuffle_epi32(STATE1, 0xB1); // DCHG
592  STATE0 = _mm_blend_epi16(TMP, STATE1, 0xF0); // DCBA
593  STATE1 = _mm_alignr_epi8(STATE1, TMP, 8); // ABEF
594 
595  // Save state
596  _mm_storeu_si128(M128_CAST(&state[0]), STATE0);
597  _mm_storeu_si128(M128_CAST(&state[4]), STATE1);
598 }
599 #endif // CRYPTOPP_SHANI_AVAILABLE
600 
601 /////////////////////////////////
602 // end of Walton/Gulley's code //
603 /////////////////////////////////
604 
605 // ***************** ARMV8 SHA ********************
606 
607 /////////////////////////////////////////////////////////
608 // start of Walton/Schneiders/O'Rourke/Hovsmith's code //
609 /////////////////////////////////////////////////////////
610 
611 #if CRYPTOPP_ARM_SHA_AVAILABLE
612 void SHA1_HashMultipleBlocks_ARMV8(word32 *state, const word32 *data, size_t length, ByteOrder order)
613 {
614  CRYPTOPP_ASSERT(state);
615  CRYPTOPP_ASSERT(data);
616  CRYPTOPP_ASSERT(length >= SHA1::BLOCKSIZE);
617 
618  uint32x4_t C0, C1, C2, C3;
619  uint32x4_t ABCD, ABCD_SAVED;
620  uint32x4_t MSG0, MSG1, MSG2, MSG3;
621  uint32x4_t TMP0, TMP1;
622  uint32_t E0, E0_SAVED, E1;
623 
624  // Load initial values
625  C0 = vdupq_n_u32(0x5A827999);
626  C1 = vdupq_n_u32(0x6ED9EBA1);
627  C2 = vdupq_n_u32(0x8F1BBCDC);
628  C3 = vdupq_n_u32(0xCA62C1D6);
629 
630  ABCD = vld1q_u32(&state[0]);
631  E0 = state[4];
632 
633  while (length >= SHA1::BLOCKSIZE)
634  {
635  // Save current hash
636  ABCD_SAVED = ABCD;
637  E0_SAVED = E0;
638 
639  MSG0 = vld1q_u32(data + 0);
640  MSG1 = vld1q_u32(data + 4);
641  MSG2 = vld1q_u32(data + 8);
642  MSG3 = vld1q_u32(data + 12);
643 
644  if (order == BIG_ENDIAN_ORDER) // Data arrangement
645  {
646  MSG0 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG0)));
647  MSG1 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG1)));
648  MSG2 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG2)));
649  MSG3 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG3)));
650  }
651 
652  TMP0 = vaddq_u32(MSG0, C0);
653  TMP1 = vaddq_u32(MSG1, C0);
654 
655  // Rounds 0-3
656  E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
657  ABCD = vsha1cq_u32(ABCD, E0, TMP0);
658  TMP0 = vaddq_u32(MSG2, C0);
659  MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2);
660 
661  // Rounds 4-7
662  E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
663  ABCD = vsha1cq_u32(ABCD, E1, TMP1);
664  TMP1 = vaddq_u32(MSG3, C0);
665  MSG0 = vsha1su1q_u32(MSG0, MSG3);
666  MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3);
667 
668  // Rounds 8-11
669  E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
670  ABCD = vsha1cq_u32(ABCD, E0, TMP0);
671  TMP0 = vaddq_u32(MSG0, C0);
672  MSG1 = vsha1su1q_u32(MSG1, MSG0);
673  MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0);
674 
675  // Rounds 12-15
676  E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
677  ABCD = vsha1cq_u32(ABCD, E1, TMP1);
678  TMP1 = vaddq_u32(MSG1, C1);
679  MSG2 = vsha1su1q_u32(MSG2, MSG1);
680  MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1);
681 
682  // Rounds 16-19
683  E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
684  ABCD = vsha1cq_u32(ABCD, E0, TMP0);
685  TMP0 = vaddq_u32(MSG2, C1);
686  MSG3 = vsha1su1q_u32(MSG3, MSG2);
687  MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2);
688 
689  // Rounds 20-23
690  E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
691  ABCD = vsha1pq_u32(ABCD, E1, TMP1);
692  TMP1 = vaddq_u32(MSG3, C1);
693  MSG0 = vsha1su1q_u32(MSG0, MSG3);
694  MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3);
695 
696  // Rounds 24-27
697  E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
698  ABCD = vsha1pq_u32(ABCD, E0, TMP0);
699  TMP0 = vaddq_u32(MSG0, C1);
700  MSG1 = vsha1su1q_u32(MSG1, MSG0);
701  MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0);
702 
703  // Rounds 28-31
704  E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
705  ABCD = vsha1pq_u32(ABCD, E1, TMP1);
706  TMP1 = vaddq_u32(MSG1, C1);
707  MSG2 = vsha1su1q_u32(MSG2, MSG1);
708  MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1);
709 
710  // Rounds 32-35
711  E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
712  ABCD = vsha1pq_u32(ABCD, E0, TMP0);
713  TMP0 = vaddq_u32(MSG2, C2);
714  MSG3 = vsha1su1q_u32(MSG3, MSG2);
715  MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2);
716 
717  // Rounds 36-39
718  E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
719  ABCD = vsha1pq_u32(ABCD, E1, TMP1);
720  TMP1 = vaddq_u32(MSG3, C2);
721  MSG0 = vsha1su1q_u32(MSG0, MSG3);
722  MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3);
723 
724  // Rounds 40-43
725  E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
726  ABCD = vsha1mq_u32(ABCD, E0, TMP0);
727  TMP0 = vaddq_u32(MSG0, C2);
728  MSG1 = vsha1su1q_u32(MSG1, MSG0);
729  MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0);
730 
731  // Rounds 44-47
732  E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
733  ABCD = vsha1mq_u32(ABCD, E1, TMP1);
734  TMP1 = vaddq_u32(MSG1, C2);
735  MSG2 = vsha1su1q_u32(MSG2, MSG1);
736  MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1);
737 
738  // Rounds 48-51
739  E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
740  ABCD = vsha1mq_u32(ABCD, E0, TMP0);
741  TMP0 = vaddq_u32(MSG2, C2);
742  MSG3 = vsha1su1q_u32(MSG3, MSG2);
743  MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2);
744 
745  // Rounds 52-55
746  E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
747  ABCD = vsha1mq_u32(ABCD, E1, TMP1);
748  TMP1 = vaddq_u32(MSG3, C3);
749  MSG0 = vsha1su1q_u32(MSG0, MSG3);
750  MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3);
751 
752  // Rounds 56-59
753  E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
754  ABCD = vsha1mq_u32(ABCD, E0, TMP0);
755  TMP0 = vaddq_u32(MSG0, C3);
756  MSG1 = vsha1su1q_u32(MSG1, MSG0);
757  MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0);
758 
759  // Rounds 60-63
760  E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
761  ABCD = vsha1pq_u32(ABCD, E1, TMP1);
762  TMP1 = vaddq_u32(MSG1, C3);
763  MSG2 = vsha1su1q_u32(MSG2, MSG1);
764  MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1);
765 
766  // Rounds 64-67
767  E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
768  ABCD = vsha1pq_u32(ABCD, E0, TMP0);
769  TMP0 = vaddq_u32(MSG2, C3);
770  MSG3 = vsha1su1q_u32(MSG3, MSG2);
771  MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2);
772 
773  // Rounds 68-71
774  E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
775  ABCD = vsha1pq_u32(ABCD, E1, TMP1);
776  TMP1 = vaddq_u32(MSG3, C3);
777  MSG0 = vsha1su1q_u32(MSG0, MSG3);
778 
779  // Rounds 72-75
780  E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
781  ABCD = vsha1pq_u32(ABCD, E0, TMP0);
782 
783  // Rounds 76-79
784  E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
785  ABCD = vsha1pq_u32(ABCD, E1, TMP1);
786 
787  E0 += E0_SAVED;
788  ABCD = vaddq_u32(ABCD_SAVED, ABCD);
789 
790  data += SHA1::BLOCKSIZE/sizeof(word32);
791  length -= SHA1::BLOCKSIZE;
792  }
793 
794  // Save state
795  vst1q_u32(&state[0], ABCD);
796  state[4] = E0;
797 }
798 
799 void SHA256_HashMultipleBlocks_ARMV8(word32 *state, const word32 *data, size_t length, ByteOrder order)
800 {
801  CRYPTOPP_ASSERT(state);
802  CRYPTOPP_ASSERT(data);
803  CRYPTOPP_ASSERT(length >= SHA256::BLOCKSIZE);
804 
805  uint32x4_t STATE0, STATE1, ABEF_SAVE, CDGH_SAVE;
806  uint32x4_t MSG0, MSG1, MSG2, MSG3;
807  uint32x4_t TMP0, TMP1, TMP2;
808 
809  // Load initial values
810  STATE0 = vld1q_u32(&state[0]);
811  STATE1 = vld1q_u32(&state[4]);
812 
813  while (length >= SHA256::BLOCKSIZE)
814  {
815  // Save current hash
816  ABEF_SAVE = STATE0;
817  CDGH_SAVE = STATE1;
818 
819  // Load message
820  MSG0 = vld1q_u32(data + 0);
821  MSG1 = vld1q_u32(data + 4);
822  MSG2 = vld1q_u32(data + 8);
823  MSG3 = vld1q_u32(data + 12);
824 
825  if (order == BIG_ENDIAN_ORDER) // Data arrangement
826  {
827  MSG0 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG0)));
828  MSG1 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG1)));
829  MSG2 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG2)));
830  MSG3 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG3)));
831  }
832 
833  TMP0 = vaddq_u32(MSG0, vld1q_u32(&SHA256_K[0x00]));
834 
835  // Rounds 0-3
836  MSG0 = vsha256su0q_u32(MSG0, MSG1);
837  TMP2 = STATE0;
838  TMP1 = vaddq_u32(MSG1, vld1q_u32(&SHA256_K[0x04]));
839  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP0);
840  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP0);
841  MSG0 = vsha256su1q_u32(MSG0, MSG2, MSG3);;
842 
843  // Rounds 4-7
844  MSG1 = vsha256su0q_u32(MSG1, MSG2);
845  TMP2 = STATE0;
846  TMP0 = vaddq_u32(MSG2, vld1q_u32(&SHA256_K[0x08]));
847  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP1);
848  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP1);
849  MSG1 = vsha256su1q_u32(MSG1, MSG3, MSG0);;
850 
851  // Rounds 8-11
852  MSG2 = vsha256su0q_u32(MSG2, MSG3);
853  TMP2 = STATE0;
854  TMP1 = vaddq_u32(MSG3, vld1q_u32(&SHA256_K[0x0c]));
855  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP0);
856  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP0);
857  MSG2 = vsha256su1q_u32(MSG2, MSG0, MSG1);;
858 
859  // Rounds 12-15
860  MSG3 = vsha256su0q_u32(MSG3, MSG0);
861  TMP2 = STATE0;
862  TMP0 = vaddq_u32(MSG0, vld1q_u32(&SHA256_K[0x10]));
863  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP1);
864  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP1);
865  MSG3 = vsha256su1q_u32(MSG3, MSG1, MSG2);;
866 
867  // Rounds 16-19
868  MSG0 = vsha256su0q_u32(MSG0, MSG1);
869  TMP2 = STATE0;
870  TMP1 = vaddq_u32(MSG1, vld1q_u32(&SHA256_K[0x14]));
871  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP0);
872  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP0);
873  MSG0 = vsha256su1q_u32(MSG0, MSG2, MSG3);;
874 
875  // Rounds 20-23
876  MSG1 = vsha256su0q_u32(MSG1, MSG2);
877  TMP2 = STATE0;
878  TMP0 = vaddq_u32(MSG2, vld1q_u32(&SHA256_K[0x18]));
879  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP1);
880  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP1);
881  MSG1 = vsha256su1q_u32(MSG1, MSG3, MSG0);;
882 
883  // Rounds 24-27
884  MSG2 = vsha256su0q_u32(MSG2, MSG3);
885  TMP2 = STATE0;
886  TMP1 = vaddq_u32(MSG3, vld1q_u32(&SHA256_K[0x1c]));
887  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP0);
888  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP0);
889  MSG2 = vsha256su1q_u32(MSG2, MSG0, MSG1);;
890 
891  // Rounds 28-31
892  MSG3 = vsha256su0q_u32(MSG3, MSG0);
893  TMP2 = STATE0;
894  TMP0 = vaddq_u32(MSG0, vld1q_u32(&SHA256_K[0x20]));
895  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP1);
896  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP1);
897  MSG3 = vsha256su1q_u32(MSG3, MSG1, MSG2);;
898 
899  // Rounds 32-35
900  MSG0 = vsha256su0q_u32(MSG0, MSG1);
901  TMP2 = STATE0;
902  TMP1 = vaddq_u32(MSG1, vld1q_u32(&SHA256_K[0x24]));
903  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP0);
904  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP0);
905  MSG0 = vsha256su1q_u32(MSG0, MSG2, MSG3);;
906 
907  // Rounds 36-39
908  MSG1 = vsha256su0q_u32(MSG1, MSG2);
909  TMP2 = STATE0;
910  TMP0 = vaddq_u32(MSG2, vld1q_u32(&SHA256_K[0x28]));
911  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP1);
912  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP1);
913  MSG1 = vsha256su1q_u32(MSG1, MSG3, MSG0);;
914 
915  // Rounds 40-43
916  MSG2 = vsha256su0q_u32(MSG2, MSG3);
917  TMP2 = STATE0;
918  TMP1 = vaddq_u32(MSG3, vld1q_u32(&SHA256_K[0x2c]));
919  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP0);
920  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP0);
921  MSG2 = vsha256su1q_u32(MSG2, MSG0, MSG1);;
922 
923  // Rounds 44-47
924  MSG3 = vsha256su0q_u32(MSG3, MSG0);
925  TMP2 = STATE0;
926  TMP0 = vaddq_u32(MSG0, vld1q_u32(&SHA256_K[0x30]));
927  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP1);
928  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP1);
929  MSG3 = vsha256su1q_u32(MSG3, MSG1, MSG2);;
930 
931  // Rounds 48-51
932  TMP2 = STATE0;
933  TMP1 = vaddq_u32(MSG1, vld1q_u32(&SHA256_K[0x34]));
934  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP0);
935  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP0);;
936 
937  // Rounds 52-55
938  TMP2 = STATE0;
939  TMP0 = vaddq_u32(MSG2, vld1q_u32(&SHA256_K[0x38]));
940  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP1);
941  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP1);;
942 
943  // Rounds 56-59
944  TMP2 = STATE0;
945  TMP1 = vaddq_u32(MSG3, vld1q_u32(&SHA256_K[0x3c]));
946  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP0);
947  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP0);;
948 
949  // Rounds 60-63
950  TMP2 = STATE0;
951  STATE0 = vsha256hq_u32(STATE0, STATE1, TMP1);
952  STATE1 = vsha256h2q_u32(STATE1, TMP2, TMP1);;
953 
954  // Add back to state
955  STATE0 = vaddq_u32(STATE0, ABEF_SAVE);
956  STATE1 = vaddq_u32(STATE1, CDGH_SAVE);
957 
958  data += SHA256::BLOCKSIZE/sizeof(word32);
959  length -= SHA256::BLOCKSIZE;
960  }
961 
962  // Save state
963  vst1q_u32(&state[0], STATE0);
964  vst1q_u32(&state[4], STATE1);
965 }
966 #endif // CRYPTOPP_ARM_SHA_AVAILABLE
967 
968 ///////////////////////////////////////////////////////
969 // end of Walton/Schneiders/O'Rourke/Hovsmith's code //
970 ///////////////////////////////////////////////////////
971 
972 // ***************** Power8 SHA ********************
973 
974 ////////////////////////////////////////////////
975 // Begin Gustavo Serra Scalet and Walton code //
976 ////////////////////////////////////////////////
977 
978 #if CRYPTOPP_POWER8_SHA_AVAILABLE
979 void SHA256_HashMultipleBlocks_POWER8(word32 *state, const word32 *data, size_t length, ByteOrder order)
980 {
981  CRYPTOPP_ASSERT(state);
982  CRYPTOPP_ASSERT(data);
983  CRYPTOPP_ASSERT(length >= SHA256::BLOCKSIZE);
984 
985  CRYPTOPP_ASSERT(0);
986 }
987 
988 void SHA512_HashMultipleBlocks_POWER8(word64 *state, const word64 *data, size_t length, ByteOrder order)
989 {
990  CRYPTOPP_ASSERT(state);
991  CRYPTOPP_ASSERT(data);
992  CRYPTOPP_ASSERT(length >= SHA512::BLOCKSIZE);
993 
994  CRYPTOPP_ASSERT(0);
995 }
996 
997 #endif // CRYPTOPP_POWER8_SHA_AVAILABLE
998 
999 //////////////////////////////////////////////
1000 // End Gustavo Serra Scalet and Walton code //
1001 //////////////////////////////////////////////
1002 
1003 NAMESPACE_END
Utility functions for the Crypto++ library.
ByteOrder
Provides the byte ordering.
Definition: cryptlib.h:140
Library configuration file.
Support functions for PowerPC and vector operations.
Precompiled header file.
byte order is big-endian
Definition: cryptlib.h:144
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Definition: trap.h:60
Classes for SHA-1 and SHA-2 family of message digests.
Crypto++ library namespace.