memset, memcpy, sizeof consistency fixes
[openssl.git] / crypto / sha / sha512.c
1 /* crypto/sha/sha512.c */
2 /* ====================================================================
3  * Copyright (c) 2004 The OpenSSL Project.  All rights reserved
4  * according to the OpenSSL license [found in ../../LICENSE].
5  * ====================================================================
6  */
7 #include <openssl/opensslconf.h>
8 /*-
9  * IMPLEMENTATION NOTES.
10  *
11  * As you might have noticed 32-bit hash algorithms:
12  *
13  * - permit SHA_LONG to be wider than 32-bit
14  * - optimized versions implement two transform functions: one operating
15  *   on [aligned] data in host byte order and one - on data in input
16  *   stream byte order;
17  * - share common byte-order neutral collector and padding function
18  *   implementations, ../md32_common.h;
19  *
20  * Neither of the above applies to this SHA-512 implementations. Reasons
21  * [in reverse order] are:
22  *
23  * - it's the only 64-bit hash algorithm for the moment of this writing,
24  *   there is no need for common collector/padding implementation [yet];
25  * - by supporting only one transform function [which operates on
26  *   *aligned* data in input stream byte order, big-endian in this case]
27  *   we minimize burden of maintenance in two ways: a) collector/padding
28  *   function is simpler; b) only one transform function to stare at;
29  * - SHA_LONG64 is required to be exactly 64-bit in order to be able to
30  *   apply a number of optimizations to mitigate potential performance
31  *   penalties caused by previous design decision;
32  *
33  * Caveat lector.
34  *
35  * Implementation relies on the fact that "long long" is 64-bit on
36  * both 32- and 64-bit platforms. If some compiler vendor comes up
37  * with 128-bit long long, adjustment to sha.h would be required.
38  * As this implementation relies on 64-bit integer type, it's totally
39  * inappropriate for platforms which don't support it, most notably
40  * 16-bit platforms.
41  *                                      <appro@fy.chalmers.se>
42  */
43 #include <stdlib.h>
44 #include <string.h>
45
46 #include <openssl/crypto.h>
47 #include <openssl/sha.h>
48 #include <openssl/opensslv.h>
49
50 #include "cryptlib.h"
51
52 const char SHA512_version[] = "SHA-512" OPENSSL_VERSION_PTEXT;
53
54 #if defined(__i386) || defined(__i386__) || defined(_M_IX86) || \
55     defined(__x86_64) || defined(_M_AMD64) || defined(_M_X64) || \
56     defined(__s390__) || defined(__s390x__) || \
57     defined(__aarch64__) || \
58     defined(SHA512_ASM)
59 # define SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
60 #endif
61
62 int SHA384_Init(SHA512_CTX *c)
63 {
64     c->h[0] = U64(0xcbbb9d5dc1059ed8);
65     c->h[1] = U64(0x629a292a367cd507);
66     c->h[2] = U64(0x9159015a3070dd17);
67     c->h[3] = U64(0x152fecd8f70e5939);
68     c->h[4] = U64(0x67332667ffc00b31);
69     c->h[5] = U64(0x8eb44a8768581511);
70     c->h[6] = U64(0xdb0c2e0d64f98fa7);
71     c->h[7] = U64(0x47b5481dbefa4fa4);
72
73     c->Nl = 0;
74     c->Nh = 0;
75     c->num = 0;
76     c->md_len = SHA384_DIGEST_LENGTH;
77     return 1;
78 }
79
80 int SHA512_Init(SHA512_CTX *c)
81 {
82     c->h[0] = U64(0x6a09e667f3bcc908);
83     c->h[1] = U64(0xbb67ae8584caa73b);
84     c->h[2] = U64(0x3c6ef372fe94f82b);
85     c->h[3] = U64(0xa54ff53a5f1d36f1);
86     c->h[4] = U64(0x510e527fade682d1);
87     c->h[5] = U64(0x9b05688c2b3e6c1f);
88     c->h[6] = U64(0x1f83d9abfb41bd6b);
89     c->h[7] = U64(0x5be0cd19137e2179);
90
91     c->Nl = 0;
92     c->Nh = 0;
93     c->num = 0;
94     c->md_len = SHA512_DIGEST_LENGTH;
95     return 1;
96 }
97
98 #ifndef SHA512_ASM
99 static
100 #endif
101 void sha512_block_data_order(SHA512_CTX *ctx, const void *in, size_t num);
102
103 int SHA512_Final(unsigned char *md, SHA512_CTX *c)
104 {
105     unsigned char *p = (unsigned char *)c->u.p;
106     size_t n = c->num;
107
108     p[n] = 0x80;                /* There always is a room for one */
109     n++;
110     if (n > (sizeof(c->u) - 16)) {
111         memset(p + n, 0, sizeof(c->u) - n);
112         n = 0;
113         sha512_block_data_order(c, p, 1);
114     }
115
116     memset(p + n, 0, sizeof(c->u) - 16 - n);
117 #ifdef  B_ENDIAN
118     c->u.d[SHA_LBLOCK - 2] = c->Nh;
119     c->u.d[SHA_LBLOCK - 1] = c->Nl;
120 #else
121     p[sizeof(c->u) - 1] = (unsigned char)(c->Nl);
122     p[sizeof(c->u) - 2] = (unsigned char)(c->Nl >> 8);
123     p[sizeof(c->u) - 3] = (unsigned char)(c->Nl >> 16);
124     p[sizeof(c->u) - 4] = (unsigned char)(c->Nl >> 24);
125     p[sizeof(c->u) - 5] = (unsigned char)(c->Nl >> 32);
126     p[sizeof(c->u) - 6] = (unsigned char)(c->Nl >> 40);
127     p[sizeof(c->u) - 7] = (unsigned char)(c->Nl >> 48);
128     p[sizeof(c->u) - 8] = (unsigned char)(c->Nl >> 56);
129     p[sizeof(c->u) - 9] = (unsigned char)(c->Nh);
130     p[sizeof(c->u) - 10] = (unsigned char)(c->Nh >> 8);
131     p[sizeof(c->u) - 11] = (unsigned char)(c->Nh >> 16);
132     p[sizeof(c->u) - 12] = (unsigned char)(c->Nh >> 24);
133     p[sizeof(c->u) - 13] = (unsigned char)(c->Nh >> 32);
134     p[sizeof(c->u) - 14] = (unsigned char)(c->Nh >> 40);
135     p[sizeof(c->u) - 15] = (unsigned char)(c->Nh >> 48);
136     p[sizeof(c->u) - 16] = (unsigned char)(c->Nh >> 56);
137 #endif
138
139     sha512_block_data_order(c, p, 1);
140
141     if (md == 0)
142         return 0;
143
144     switch (c->md_len) {
145         /* Let compiler decide if it's appropriate to unroll... */
146     case SHA384_DIGEST_LENGTH:
147         for (n = 0; n < SHA384_DIGEST_LENGTH / 8; n++) {
148             SHA_LONG64 t = c->h[n];
149
150             *(md++) = (unsigned char)(t >> 56);
151             *(md++) = (unsigned char)(t >> 48);
152             *(md++) = (unsigned char)(t >> 40);
153             *(md++) = (unsigned char)(t >> 32);
154             *(md++) = (unsigned char)(t >> 24);
155             *(md++) = (unsigned char)(t >> 16);
156             *(md++) = (unsigned char)(t >> 8);
157             *(md++) = (unsigned char)(t);
158         }
159         break;
160     case SHA512_DIGEST_LENGTH:
161         for (n = 0; n < SHA512_DIGEST_LENGTH / 8; n++) {
162             SHA_LONG64 t = c->h[n];
163
164             *(md++) = (unsigned char)(t >> 56);
165             *(md++) = (unsigned char)(t >> 48);
166             *(md++) = (unsigned char)(t >> 40);
167             *(md++) = (unsigned char)(t >> 32);
168             *(md++) = (unsigned char)(t >> 24);
169             *(md++) = (unsigned char)(t >> 16);
170             *(md++) = (unsigned char)(t >> 8);
171             *(md++) = (unsigned char)(t);
172         }
173         break;
174         /* ... as well as make sure md_len is not abused. */
175     default:
176         return 0;
177     }
178
179     return 1;
180 }
181
182 int SHA384_Final(unsigned char *md, SHA512_CTX *c)
183 {
184     return SHA512_Final(md, c);
185 }
186
187 int SHA512_Update(SHA512_CTX *c, const void *_data, size_t len)
188 {
189     SHA_LONG64 l;
190     unsigned char *p = c->u.p;
191     const unsigned char *data = (const unsigned char *)_data;
192
193     if (len == 0)
194         return 1;
195
196     l = (c->Nl + (((SHA_LONG64) len) << 3)) & U64(0xffffffffffffffff);
197     if (l < c->Nl)
198         c->Nh++;
199     if (sizeof(len) >= 8)
200         c->Nh += (((SHA_LONG64) len) >> 61);
201     c->Nl = l;
202
203     if (c->num != 0) {
204         size_t n = sizeof(c->u) - c->num;
205
206         if (len < n) {
207             memcpy(p + c->num, data, len), c->num += (unsigned int)len;
208             return 1;
209         } else {
210             memcpy(p + c->num, data, n), c->num = 0;
211             len -= n, data += n;
212             sha512_block_data_order(c, p, 1);
213         }
214     }
215
216     if (len >= sizeof(c->u)) {
217 #ifndef SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
218         if ((size_t)data % sizeof(c->u.d[0]) != 0)
219             while (len >= sizeof(c->u))
220                 memcpy(p, data, sizeof(c->u)),
221                     sha512_block_data_order(c, p, 1),
222                     len -= sizeof(c->u), data += sizeof(c->u);
223         else
224 #endif
225             sha512_block_data_order(c, data, len / sizeof(c->u)),
226                 data += len, len %= sizeof(c->u), data -= len;
227     }
228
229     if (len != 0)
230         memcpy(p, data, len), c->num = (int)len;
231
232     return 1;
233 }
234
235 int SHA384_Update(SHA512_CTX *c, const void *data, size_t len)
236 {
237     return SHA512_Update(c, data, len);
238 }
239
240 void SHA512_Transform(SHA512_CTX *c, const unsigned char *data)
241 {
242 #ifndef SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
243     if ((size_t)data % sizeof(c->u.d[0]) != 0)
244         memcpy(c->u.p, data, sizeof(c->u.p)), data = c->u.p;
245 #endif
246     sha512_block_data_order(c, data, 1);
247 }
248
249 unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md)
250 {
251     SHA512_CTX c;
252     static unsigned char m[SHA384_DIGEST_LENGTH];
253
254     if (md == NULL)
255         md = m;
256     SHA384_Init(&c);
257     SHA512_Update(&c, d, n);
258     SHA512_Final(md, &c);
259     OPENSSL_cleanse(&c, sizeof(c));
260     return (md);
261 }
262
263 unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md)
264 {
265     SHA512_CTX c;
266     static unsigned char m[SHA512_DIGEST_LENGTH];
267
268     if (md == NULL)
269         md = m;
270     SHA512_Init(&c);
271     SHA512_Update(&c, d, n);
272     SHA512_Final(md, &c);
273     OPENSSL_cleanse(&c, sizeof(c));
274     return (md);
275 }
276
277 #ifndef SHA512_ASM
278 static const SHA_LONG64 K512[80] = {
279     U64(0x428a2f98d728ae22), U64(0x7137449123ef65cd),
280     U64(0xb5c0fbcfec4d3b2f), U64(0xe9b5dba58189dbbc),
281     U64(0x3956c25bf348b538), U64(0x59f111f1b605d019),
282     U64(0x923f82a4af194f9b), U64(0xab1c5ed5da6d8118),
283     U64(0xd807aa98a3030242), U64(0x12835b0145706fbe),
284     U64(0x243185be4ee4b28c), U64(0x550c7dc3d5ffb4e2),
285     U64(0x72be5d74f27b896f), U64(0x80deb1fe3b1696b1),
286     U64(0x9bdc06a725c71235), U64(0xc19bf174cf692694),
287     U64(0xe49b69c19ef14ad2), U64(0xefbe4786384f25e3),
288     U64(0x0fc19dc68b8cd5b5), U64(0x240ca1cc77ac9c65),
289     U64(0x2de92c6f592b0275), U64(0x4a7484aa6ea6e483),
290     U64(0x5cb0a9dcbd41fbd4), U64(0x76f988da831153b5),
291     U64(0x983e5152ee66dfab), U64(0xa831c66d2db43210),
292     U64(0xb00327c898fb213f), U64(0xbf597fc7beef0ee4),
293     U64(0xc6e00bf33da88fc2), U64(0xd5a79147930aa725),
294     U64(0x06ca6351e003826f), U64(0x142929670a0e6e70),
295     U64(0x27b70a8546d22ffc), U64(0x2e1b21385c26c926),
296     U64(0x4d2c6dfc5ac42aed), U64(0x53380d139d95b3df),
297     U64(0x650a73548baf63de), U64(0x766a0abb3c77b2a8),
298     U64(0x81c2c92e47edaee6), U64(0x92722c851482353b),
299     U64(0xa2bfe8a14cf10364), U64(0xa81a664bbc423001),
300     U64(0xc24b8b70d0f89791), U64(0xc76c51a30654be30),
301     U64(0xd192e819d6ef5218), U64(0xd69906245565a910),
302     U64(0xf40e35855771202a), U64(0x106aa07032bbd1b8),
303     U64(0x19a4c116b8d2d0c8), U64(0x1e376c085141ab53),
304     U64(0x2748774cdf8eeb99), U64(0x34b0bcb5e19b48a8),
305     U64(0x391c0cb3c5c95a63), U64(0x4ed8aa4ae3418acb),
306     U64(0x5b9cca4f7763e373), U64(0x682e6ff3d6b2b8a3),
307     U64(0x748f82ee5defb2fc), U64(0x78a5636f43172f60),
308     U64(0x84c87814a1f0ab72), U64(0x8cc702081a6439ec),
309     U64(0x90befffa23631e28), U64(0xa4506cebde82bde9),
310     U64(0xbef9a3f7b2c67915), U64(0xc67178f2e372532b),
311     U64(0xca273eceea26619c), U64(0xd186b8c721c0c207),
312     U64(0xeada7dd6cde0eb1e), U64(0xf57d4f7fee6ed178),
313     U64(0x06f067aa72176fba), U64(0x0a637dc5a2c898a6),
314     U64(0x113f9804bef90dae), U64(0x1b710b35131c471b),
315     U64(0x28db77f523047d84), U64(0x32caab7b40c72493),
316     U64(0x3c9ebe0a15c9bebc), U64(0x431d67c49c100d4c),
317     U64(0x4cc5d4becb3e42b6), U64(0x597f299cfc657e2a),
318     U64(0x5fcb6fab3ad6faec), U64(0x6c44198c4a475817)
319 };
320
321 # ifndef PEDANTIC
322 #  if defined(__GNUC__) && __GNUC__>=2 && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM)
323 #   if defined(__x86_64) || defined(__x86_64__)
324 #    define ROTR(a,n)    ({ SHA_LONG64 ret;              \
325                                 asm ("rorq %1,%0"       \
326                                 : "=r"(ret)             \
327                                 : "J"(n),"0"(a)         \
328                                 : "cc"); ret;           })
329 #    if !defined(B_ENDIAN)
330 #     define PULL64(x) ({ SHA_LONG64 ret=*((const SHA_LONG64 *)(&(x)));  \
331                                 asm ("bswapq    %0"             \
332                                 : "=r"(ret)                     \
333                                 : "0"(ret)); ret;               })
334 #    endif
335 #   elif (defined(__i386) || defined(__i386__)) && !defined(B_ENDIAN)
336 #    if defined(I386_ONLY)
337 #     define PULL64(x) ({ const unsigned int *p=(const unsigned int *)(&(x));\
338                          unsigned int hi=p[0],lo=p[1];          \
339                                 asm("xchgb %%ah,%%al;xchgb %%dh,%%dl;"\
340                                     "roll $16,%%eax; roll $16,%%edx; "\
341                                     "xchgb %%ah,%%al;xchgb %%dh,%%dl;" \
342                                 : "=a"(lo),"=d"(hi)             \
343                                 : "0"(lo),"1"(hi) : "cc");      \
344                                 ((SHA_LONG64)hi)<<32|lo;        })
345 #    else
346 #     define PULL64(x) ({ const unsigned int *p=(const unsigned int *)(&(x));\
347                          unsigned int hi=p[0],lo=p[1];          \
348                                 asm ("bswapl %0; bswapl %1;"    \
349                                 : "=r"(lo),"=r"(hi)             \
350                                 : "0"(lo),"1"(hi));             \
351                                 ((SHA_LONG64)hi)<<32|lo;        })
352 #    endif
353 #   elif (defined(_ARCH_PPC) && defined(__64BIT__)) || defined(_ARCH_PPC64)
354 #    define ROTR(a,n)    ({ SHA_LONG64 ret;              \
355                                 asm ("rotrdi %0,%1,%2"  \
356                                 : "=r"(ret)             \
357                                 : "r"(a),"K"(n)); ret;  })
358 #   elif defined(__aarch64__)
359 #    define ROTR(a,n)    ({ SHA_LONG64 ret;              \
360                                 asm ("ror %0,%1,%2"     \
361                                 : "=r"(ret)             \
362                                 : "r"(a),"I"(n)); ret;  })
363 #    if  defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
364         __BYTE_ORDER__==__ORDER_LITTLE_ENDIAN__
365 #     define PULL64(x)   ({ SHA_LONG64 ret;                      \
366                                 asm ("rev       %0,%1"          \
367                                 : "=r"(ret)                     \
368                                 : "r"(*((const SHA_LONG64 *)(&(x))))); ret;             })
369 #    endif
370 #   endif
371 #  elif defined(_MSC_VER)
372 #   if defined(_WIN64)         /* applies to both IA-64 and AMD64 */
373 #    pragma intrinsic(_rotr64)
374 #    define ROTR(a,n)    _rotr64((a),n)
375 #   endif
376 #   if defined(_M_IX86) && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM)
377 #    if defined(I386_ONLY)
378 static SHA_LONG64 __fastcall __pull64be(const void *x)
379 {
380     _asm mov edx,[ecx + 0]
381     _asm mov eax,[ecx + 4]
382 _asm xchg dh, dl
383         _asm xchg ah, al
384         _asm rol edx, 16 _asm rol eax, 16 _asm xchg dh, dl _asm xchg ah, al}
385 #    else
386 static SHA_LONG64 __fastcall __pull64be(const void *x)
387 {
388     _asm mov edx,[ecx + 0]
389     _asm mov eax,[ecx + 4]
390 _asm bswap edx _asm bswap eax}
391 #    endif
392 #    define PULL64(x) __pull64be(&(x))
393 #    if _MSC_VER<=1200
394 #     pragma inline_depth(0)
395 #    endif
396 #   endif
397 #  endif
398 # endif
399 # ifndef PULL64
400 #  define B(x,j)    (((SHA_LONG64)(*(((const unsigned char *)(&x))+j)))<<((7-j)*8))
401 #  define PULL64(x) (B(x,0)|B(x,1)|B(x,2)|B(x,3)|B(x,4)|B(x,5)|B(x,6)|B(x,7))
402 # endif
403 # ifndef ROTR
404 #  define ROTR(x,s)       (((x)>>s) | (x)<<(64-s))
405 # endif
406 # define Sigma0(x)       (ROTR((x),28) ^ ROTR((x),34) ^ ROTR((x),39))
407 # define Sigma1(x)       (ROTR((x),14) ^ ROTR((x),18) ^ ROTR((x),41))
408 # define sigma0(x)       (ROTR((x),1)  ^ ROTR((x),8)  ^ ((x)>>7))
409 # define sigma1(x)       (ROTR((x),19) ^ ROTR((x),61) ^ ((x)>>6))
410 # define Ch(x,y,z)       (((x) & (y)) ^ ((~(x)) & (z)))
411 # define Maj(x,y,z)      (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
412 # if defined(__i386) || defined(__i386__) || defined(_M_IX86)
413 /*
414  * This code should give better results on 32-bit CPU with less than
415  * ~24 registers, both size and performance wise...
416  */ static void sha512_block_data_order(SHA512_CTX *ctx, const void *in,
417                                         size_t num)
418 {
419     const SHA_LONG64 *W = in;
420     SHA_LONG64 A, E, T;
421     SHA_LONG64 X[9 + 80], *F;
422     int i;
423
424     while (num--) {
425
426         F = X + 80;
427         A = ctx->h[0];
428         F[1] = ctx->h[1];
429         F[2] = ctx->h[2];
430         F[3] = ctx->h[3];
431         E = ctx->h[4];
432         F[5] = ctx->h[5];
433         F[6] = ctx->h[6];
434         F[7] = ctx->h[7];
435
436         for (i = 0; i < 16; i++, F--) {
437 #  ifdef B_ENDIAN
438             T = W[i];
439 #  else
440             T = PULL64(W[i]);
441 #  endif
442             F[0] = A;
443             F[4] = E;
444             F[8] = T;
445             T += F[7] + Sigma1(E) + Ch(E, F[5], F[6]) + K512[i];
446             E = F[3] + T;
447             A = T + Sigma0(A) + Maj(A, F[1], F[2]);
448         }
449
450         for (; i < 80; i++, F--) {
451             T = sigma0(F[8 + 16 - 1]);
452             T += sigma1(F[8 + 16 - 14]);
453             T += F[8 + 16] + F[8 + 16 - 9];
454
455             F[0] = A;
456             F[4] = E;
457             F[8] = T;
458             T += F[7] + Sigma1(E) + Ch(E, F[5], F[6]) + K512[i];
459             E = F[3] + T;
460             A = T + Sigma0(A) + Maj(A, F[1], F[2]);
461         }
462
463         ctx->h[0] += A;
464         ctx->h[1] += F[1];
465         ctx->h[2] += F[2];
466         ctx->h[3] += F[3];
467         ctx->h[4] += E;
468         ctx->h[5] += F[5];
469         ctx->h[6] += F[6];
470         ctx->h[7] += F[7];
471
472         W += SHA_LBLOCK;
473     }
474 }
475
476 # elif defined(OPENSSL_SMALL_FOOTPRINT)
477 static void sha512_block_data_order(SHA512_CTX *ctx, const void *in,
478                                     size_t num)
479 {
480     const SHA_LONG64 *W = in;
481     SHA_LONG64 a, b, c, d, e, f, g, h, s0, s1, T1, T2;
482     SHA_LONG64 X[16];
483     int i;
484
485     while (num--) {
486
487         a = ctx->h[0];
488         b = ctx->h[1];
489         c = ctx->h[2];
490         d = ctx->h[3];
491         e = ctx->h[4];
492         f = ctx->h[5];
493         g = ctx->h[6];
494         h = ctx->h[7];
495
496         for (i = 0; i < 16; i++) {
497 #  ifdef B_ENDIAN
498             T1 = X[i] = W[i];
499 #  else
500             T1 = X[i] = PULL64(W[i]);
501 #  endif
502             T1 += h + Sigma1(e) + Ch(e, f, g) + K512[i];
503             T2 = Sigma0(a) + Maj(a, b, c);
504             h = g;
505             g = f;
506             f = e;
507             e = d + T1;
508             d = c;
509             c = b;
510             b = a;
511             a = T1 + T2;
512         }
513
514         for (; i < 80; i++) {
515             s0 = X[(i + 1) & 0x0f];
516             s0 = sigma0(s0);
517             s1 = X[(i + 14) & 0x0f];
518             s1 = sigma1(s1);
519
520             T1 = X[i & 0xf] += s0 + s1 + X[(i + 9) & 0xf];
521             T1 += h + Sigma1(e) + Ch(e, f, g) + K512[i];
522             T2 = Sigma0(a) + Maj(a, b, c);
523             h = g;
524             g = f;
525             f = e;
526             e = d + T1;
527             d = c;
528             c = b;
529             b = a;
530             a = T1 + T2;
531         }
532
533         ctx->h[0] += a;
534         ctx->h[1] += b;
535         ctx->h[2] += c;
536         ctx->h[3] += d;
537         ctx->h[4] += e;
538         ctx->h[5] += f;
539         ctx->h[6] += g;
540         ctx->h[7] += h;
541
542         W += SHA_LBLOCK;
543     }
544 }
545
546 # else
547 #  define ROUND_00_15(i,a,b,c,d,e,f,g,h)          do {    \
548         T1 += h + Sigma1(e) + Ch(e,f,g) + K512[i];      \
549         h = Sigma0(a) + Maj(a,b,c);                     \
550         d += T1;        h += T1;                } while (0)
551 #  define ROUND_16_80(i,j,a,b,c,d,e,f,g,h,X)      do {    \
552         s0 = X[(j+1)&0x0f];     s0 = sigma0(s0);        \
553         s1 = X[(j+14)&0x0f];    s1 = sigma1(s1);        \
554         T1 = X[(j)&0x0f] += s0 + s1 + X[(j+9)&0x0f];    \
555         ROUND_00_15(i+j,a,b,c,d,e,f,g,h);               } while (0)
556 static void sha512_block_data_order(SHA512_CTX *ctx, const void *in,
557                                     size_t num)
558 {
559     const SHA_LONG64 *W = in;
560     SHA_LONG64 a, b, c, d, e, f, g, h, s0, s1, T1;
561     SHA_LONG64 X[16];
562     int i;
563
564     while (num--) {
565
566         a = ctx->h[0];
567         b = ctx->h[1];
568         c = ctx->h[2];
569         d = ctx->h[3];
570         e = ctx->h[4];
571         f = ctx->h[5];
572         g = ctx->h[6];
573         h = ctx->h[7];
574
575 #  ifdef B_ENDIAN
576         T1 = X[0] = W[0];
577         ROUND_00_15(0, a, b, c, d, e, f, g, h);
578         T1 = X[1] = W[1];
579         ROUND_00_15(1, h, a, b, c, d, e, f, g);
580         T1 = X[2] = W[2];
581         ROUND_00_15(2, g, h, a, b, c, d, e, f);
582         T1 = X[3] = W[3];
583         ROUND_00_15(3, f, g, h, a, b, c, d, e);
584         T1 = X[4] = W[4];
585         ROUND_00_15(4, e, f, g, h, a, b, c, d);
586         T1 = X[5] = W[5];
587         ROUND_00_15(5, d, e, f, g, h, a, b, c);
588         T1 = X[6] = W[6];
589         ROUND_00_15(6, c, d, e, f, g, h, a, b);
590         T1 = X[7] = W[7];
591         ROUND_00_15(7, b, c, d, e, f, g, h, a);
592         T1 = X[8] = W[8];
593         ROUND_00_15(8, a, b, c, d, e, f, g, h);
594         T1 = X[9] = W[9];
595         ROUND_00_15(9, h, a, b, c, d, e, f, g);
596         T1 = X[10] = W[10];
597         ROUND_00_15(10, g, h, a, b, c, d, e, f);
598         T1 = X[11] = W[11];
599         ROUND_00_15(11, f, g, h, a, b, c, d, e);
600         T1 = X[12] = W[12];
601         ROUND_00_15(12, e, f, g, h, a, b, c, d);
602         T1 = X[13] = W[13];
603         ROUND_00_15(13, d, e, f, g, h, a, b, c);
604         T1 = X[14] = W[14];
605         ROUND_00_15(14, c, d, e, f, g, h, a, b);
606         T1 = X[15] = W[15];
607         ROUND_00_15(15, b, c, d, e, f, g, h, a);
608 #  else
609         T1 = X[0] = PULL64(W[0]);
610         ROUND_00_15(0, a, b, c, d, e, f, g, h);
611         T1 = X[1] = PULL64(W[1]);
612         ROUND_00_15(1, h, a, b, c, d, e, f, g);
613         T1 = X[2] = PULL64(W[2]);
614         ROUND_00_15(2, g, h, a, b, c, d, e, f);
615         T1 = X[3] = PULL64(W[3]);
616         ROUND_00_15(3, f, g, h, a, b, c, d, e);
617         T1 = X[4] = PULL64(W[4]);
618         ROUND_00_15(4, e, f, g, h, a, b, c, d);
619         T1 = X[5] = PULL64(W[5]);
620         ROUND_00_15(5, d, e, f, g, h, a, b, c);
621         T1 = X[6] = PULL64(W[6]);
622         ROUND_00_15(6, c, d, e, f, g, h, a, b);
623         T1 = X[7] = PULL64(W[7]);
624         ROUND_00_15(7, b, c, d, e, f, g, h, a);
625         T1 = X[8] = PULL64(W[8]);
626         ROUND_00_15(8, a, b, c, d, e, f, g, h);
627         T1 = X[9] = PULL64(W[9]);
628         ROUND_00_15(9, h, a, b, c, d, e, f, g);
629         T1 = X[10] = PULL64(W[10]);
630         ROUND_00_15(10, g, h, a, b, c, d, e, f);
631         T1 = X[11] = PULL64(W[11]);
632         ROUND_00_15(11, f, g, h, a, b, c, d, e);
633         T1 = X[12] = PULL64(W[12]);
634         ROUND_00_15(12, e, f, g, h, a, b, c, d);
635         T1 = X[13] = PULL64(W[13]);
636         ROUND_00_15(13, d, e, f, g, h, a, b, c);
637         T1 = X[14] = PULL64(W[14]);
638         ROUND_00_15(14, c, d, e, f, g, h, a, b);
639         T1 = X[15] = PULL64(W[15]);
640         ROUND_00_15(15, b, c, d, e, f, g, h, a);
641 #  endif
642
643         for (i = 16; i < 80; i += 16) {
644             ROUND_16_80(i, 0, a, b, c, d, e, f, g, h, X);
645             ROUND_16_80(i, 1, h, a, b, c, d, e, f, g, X);
646             ROUND_16_80(i, 2, g, h, a, b, c, d, e, f, X);
647             ROUND_16_80(i, 3, f, g, h, a, b, c, d, e, X);
648             ROUND_16_80(i, 4, e, f, g, h, a, b, c, d, X);
649             ROUND_16_80(i, 5, d, e, f, g, h, a, b, c, X);
650             ROUND_16_80(i, 6, c, d, e, f, g, h, a, b, X);
651             ROUND_16_80(i, 7, b, c, d, e, f, g, h, a, X);
652             ROUND_16_80(i, 8, a, b, c, d, e, f, g, h, X);
653             ROUND_16_80(i, 9, h, a, b, c, d, e, f, g, X);
654             ROUND_16_80(i, 10, g, h, a, b, c, d, e, f, X);
655             ROUND_16_80(i, 11, f, g, h, a, b, c, d, e, X);
656             ROUND_16_80(i, 12, e, f, g, h, a, b, c, d, X);
657             ROUND_16_80(i, 13, d, e, f, g, h, a, b, c, X);
658             ROUND_16_80(i, 14, c, d, e, f, g, h, a, b, X);
659             ROUND_16_80(i, 15, b, c, d, e, f, g, h, a, X);
660         }
661
662         ctx->h[0] += a;
663         ctx->h[1] += b;
664         ctx->h[2] += c;
665         ctx->h[3] += d;
666         ctx->h[4] += e;
667         ctx->h[5] += f;
668         ctx->h[6] += g;
669         ctx->h[7] += h;
670
671         W += SHA_LBLOCK;
672     }
673 }
674
675 # endif
676
677 #endif                         /* SHA512_ASM */