crypto/sha/sha512.c

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