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