crypto/sha/sha256.c

   1 /* ====================================================================
   2  * Copyright (c) 2004 The OpenSSL Project.  All rights reserved
   3  * according to the OpenSSL license [found in ../../LICENSE].
   4  * ====================================================================
   5  */
   6 #include <openssl/opensslconf.h>
   7
   8 #include <stdlib.h>
   9 #include <string.h>
  10
  11 #include <openssl/crypto.h>
  12 #include <openssl/sha.h>
  13 #include <openssl/opensslv.h>
  14
  15 int SHA224_Init(SHA256_CTX *c)
  16 {
  17     memset(c, 0, sizeof(*c));
  18     c->h[0] = 0xc1059ed8UL;
  19     c->h[1] = 0x367cd507UL;
  20     c->h[2] = 0x3070dd17UL;
  21     c->h[3] = 0xf70e5939UL;
  22     c->h[4] = 0xffc00b31UL;
  23     c->h[5] = 0x68581511UL;
  24     c->h[6] = 0x64f98fa7UL;
  25     c->h[7] = 0xbefa4fa4UL;
  26     c->md_len = SHA224_DIGEST_LENGTH;
  27     return 1;
  28 }
  29
  30 int SHA256_Init(SHA256_CTX *c)
  31 {
  32     memset(c, 0, sizeof(*c));
  33     c->h[0] = 0x6a09e667UL;
  34     c->h[1] = 0xbb67ae85UL;
  35     c->h[2] = 0x3c6ef372UL;
  36     c->h[3] = 0xa54ff53aUL;
  37     c->h[4] = 0x510e527fUL;
  38     c->h[5] = 0x9b05688cUL;
  39     c->h[6] = 0x1f83d9abUL;
  40     c->h[7] = 0x5be0cd19UL;
  41     c->md_len = SHA256_DIGEST_LENGTH;
  42     return 1;
  43 }
  44
  45 unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md)
  46 {
  47     SHA256_CTX c;
  48     static unsigned char m[SHA224_DIGEST_LENGTH];
  49
  50     if (md == NULL)
  51         md = m;
  52     SHA224_Init(&c);
  53     SHA256_Update(&c, d, n);
  54     SHA256_Final(md, &c);
  55     OPENSSL_cleanse(&c, sizeof(c));
  56     return (md);
  57 }
  58
  59 unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md)
  60 {
  61     SHA256_CTX c;
  62     static unsigned char m[SHA256_DIGEST_LENGTH];
  63
  64     if (md == NULL)
  65         md = m;
  66     SHA256_Init(&c);
  67     SHA256_Update(&c, d, n);
  68     SHA256_Final(md, &c);
  69     OPENSSL_cleanse(&c, sizeof(c));
  70     return (md);
  71 }
  72
  73 int SHA224_Update(SHA256_CTX *c, const void *data, size_t len)
  74 {
  75     return SHA256_Update(c, data, len);
  76 }
  77
  78 int SHA224_Final(unsigned char *md, SHA256_CTX *c)
  79 {
  80     return SHA256_Final(md, c);
  81 }
  82
  83 #define DATA_ORDER_IS_BIG_ENDIAN
  84
  85 #define HASH_LONG               SHA_LONG
  86 #define HASH_CTX                SHA256_CTX
  87 #define HASH_CBLOCK             SHA_CBLOCK
  88
  89 /*
  90  * Note that FIPS180-2 discusses "Truncation of the Hash Function Output."
  91  * default: case below covers for it. It's not clear however if it's
  92  * permitted to truncate to amount of bytes not divisible by 4. I bet not,
  93  * but if it is, then default: case shall be extended. For reference.
  94  * Idea behind separate cases for pre-defined lenghts is to let the
  95  * compiler decide if it's appropriate to unroll small loops.
  96  */
  97 #define HASH_MAKE_STRING(c,s)   do {    \
  98         unsigned long ll;               \
  99         unsigned int  nn;               \
 100         switch ((c)->md_len)            \
 101         {   case SHA224_DIGEST_LENGTH:  \
 102                 for (nn=0;nn<SHA224_DIGEST_LENGTH/4;nn++)       \
 103                 {   ll=(c)->h[nn]; (void)HOST_l2c(ll,(s));   }  \
 104                 break;                  \
 105             case SHA256_DIGEST_LENGTH:  \
 106                 for (nn=0;nn<SHA256_DIGEST_LENGTH/4;nn++)       \
 107                 {   ll=(c)->h[nn]; (void)HOST_l2c(ll,(s));   }  \
 108                 break;                  \
 109             default:                    \
 110                 if ((c)->md_len > SHA256_DIGEST_LENGTH) \
 111                     return 0;                           \
 112                 for (nn=0;nn<(c)->md_len/4;nn++)                \
 113                 {   ll=(c)->h[nn]; (void)HOST_l2c(ll,(s));   }  \
 114                 break;                  \
 115         }                               \
 116         } while (0)
 117
 118 #define HASH_UPDATE             SHA256_Update
 119 #define HASH_TRANSFORM          SHA256_Transform
 120 #define HASH_FINAL              SHA256_Final
 121 #define HASH_BLOCK_DATA_ORDER   sha256_block_data_order
 122 #ifndef SHA256_ASM
 123 static
 124 #endif
 125 void sha256_block_data_order(SHA256_CTX *ctx, const void *in, size_t num);
 126
 127 #include "internal/md32_common.h"
 128
 129 #ifndef SHA256_ASM
 130 static const SHA_LONG K256[64] = {
 131     0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
 132     0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
 133     0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
 134     0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL,
 135     0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
 136     0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
 137     0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL,
 138     0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL,
 139     0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL,
 140     0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
 141     0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL,
 142     0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL,
 143     0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL,
 144     0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL,
 145     0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
 146     0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
 147 };
 148
 149 /*
 150  * FIPS specification refers to right rotations, while our ROTATE macro
 151  * is left one. This is why you might notice that rotation coefficients
 152  * differ from those observed in FIPS document by 32-N...
 153  */
 154 # define Sigma0(x)       (ROTATE((x),30) ^ ROTATE((x),19) ^ ROTATE((x),10))
 155 # define Sigma1(x)       (ROTATE((x),26) ^ ROTATE((x),21) ^ ROTATE((x),7))
 156 # define sigma0(x)       (ROTATE((x),25) ^ ROTATE((x),14) ^ ((x)>>3))
 157 # define sigma1(x)       (ROTATE((x),15) ^ ROTATE((x),13) ^ ((x)>>10))
 158
 159 # define Ch(x,y,z)       (((x) & (y)) ^ ((~(x)) & (z)))
 160 # define Maj(x,y,z)      (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
 161
 162 # ifdef OPENSSL_SMALL_FOOTPRINT
 163
 164 static void sha256_block_data_order(SHA256_CTX *ctx, const void *in,
 165                                     size_t num)
 166 {
 167     unsigned MD32_REG_T a, b, c, d, e, f, g, h, s0, s1, T1, T2;
 168     SHA_LONG X[16], l;
 169     int i;
 170     const unsigned char *data = in;
 171
 172     while (num--) {
 173
 174         a = ctx->h[0];
 175         b = ctx->h[1];
 176         c = ctx->h[2];
 177         d = ctx->h[3];
 178         e = ctx->h[4];
 179         f = ctx->h[5];
 180         g = ctx->h[6];
 181         h = ctx->h[7];
 182
 183         for (i = 0; i < 16; i++) {
 184             HOST_c2l(data, l);
 185             T1 = X[i] = l;
 186             T1 += h + Sigma1(e) + Ch(e, f, g) + K256[i];
 187             T2 = Sigma0(a) + Maj(a, b, c);
 188             h = g;
 189             g = f;
 190             f = e;
 191             e = d + T1;
 192             d = c;
 193             c = b;
 194             b = a;
 195             a = T1 + T2;
 196         }
 197
 198         for (; i < 64; i++) {
 199             s0 = X[(i + 1) & 0x0f];
 200             s0 = sigma0(s0);
 201             s1 = X[(i + 14) & 0x0f];
 202             s1 = sigma1(s1);
 203
 204             T1 = X[i & 0xf] += s0 + s1 + X[(i + 9) & 0xf];
 205             T1 += h + Sigma1(e) + Ch(e, f, g) + K256[i];
 206             T2 = Sigma0(a) + Maj(a, b, c);
 207             h = g;
 208             g = f;
 209             f = e;
 210             e = d + T1;
 211             d = c;
 212             c = b;
 213             b = a;
 214             a = T1 + T2;
 215         }
 216
 217         ctx->h[0] += a;
 218         ctx->h[1] += b;
 219         ctx->h[2] += c;
 220         ctx->h[3] += d;
 221         ctx->h[4] += e;
 222         ctx->h[5] += f;
 223         ctx->h[6] += g;
 224         ctx->h[7] += h;
 225
 226     }
 227 }
 228
 229 # else
 230
 231 #  define ROUND_00_15(i,a,b,c,d,e,f,g,h)          do {    \
 232         T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i];      \
 233         h = Sigma0(a) + Maj(a,b,c);                     \
 234         d += T1;        h += T1;                } while (0)
 235
 236 #  define ROUND_16_63(i,a,b,c,d,e,f,g,h,X)        do {    \
 237         s0 = X[(i+1)&0x0f];     s0 = sigma0(s0);        \
 238         s1 = X[(i+14)&0x0f];    s1 = sigma1(s1);        \
 239         T1 = X[(i)&0x0f] += s0 + s1 + X[(i+9)&0x0f];    \
 240         ROUND_00_15(i,a,b,c,d,e,f,g,h);         } while (0)
 241
 242 static void sha256_block_data_order(SHA256_CTX *ctx, const void *in,
 243                                     size_t num)
 244 {
 245     unsigned MD32_REG_T a, b, c, d, e, f, g, h, s0, s1, T1;
 246     SHA_LONG X[16];
 247     int i;
 248     const unsigned char *data = in;
 249     const union {
 250         long one;
 251         char little;
 252     } is_endian = {
 253         1
 254     };
 255
 256     while (num--) {
 257
 258         a = ctx->h[0];
 259         b = ctx->h[1];
 260         c = ctx->h[2];
 261         d = ctx->h[3];
 262         e = ctx->h[4];
 263         f = ctx->h[5];
 264         g = ctx->h[6];
 265         h = ctx->h[7];
 266
 267         if (!is_endian.little && sizeof(SHA_LONG) == 4
 268             && ((size_t)in % 4) == 0) {
 269             const SHA_LONG *W = (const SHA_LONG *)data;
 270
 271             T1 = X[0] = W[0];
 272             ROUND_00_15(0, a, b, c, d, e, f, g, h);
 273             T1 = X[1] = W[1];
 274             ROUND_00_15(1, h, a, b, c, d, e, f, g);
 275             T1 = X[2] = W[2];
 276             ROUND_00_15(2, g, h, a, b, c, d, e, f);
 277             T1 = X[3] = W[3];
 278             ROUND_00_15(3, f, g, h, a, b, c, d, e);
 279             T1 = X[4] = W[4];
 280             ROUND_00_15(4, e, f, g, h, a, b, c, d);
 281             T1 = X[5] = W[5];
 282             ROUND_00_15(5, d, e, f, g, h, a, b, c);
 283             T1 = X[6] = W[6];
 284             ROUND_00_15(6, c, d, e, f, g, h, a, b);
 285             T1 = X[7] = W[7];
 286             ROUND_00_15(7, b, c, d, e, f, g, h, a);
 287             T1 = X[8] = W[8];
 288             ROUND_00_15(8, a, b, c, d, e, f, g, h);
 289             T1 = X[9] = W[9];
 290             ROUND_00_15(9, h, a, b, c, d, e, f, g);
 291             T1 = X[10] = W[10];
 292             ROUND_00_15(10, g, h, a, b, c, d, e, f);
 293             T1 = X[11] = W[11];
 294             ROUND_00_15(11, f, g, h, a, b, c, d, e);
 295             T1 = X[12] = W[12];
 296             ROUND_00_15(12, e, f, g, h, a, b, c, d);
 297             T1 = X[13] = W[13];
 298             ROUND_00_15(13, d, e, f, g, h, a, b, c);
 299             T1 = X[14] = W[14];
 300             ROUND_00_15(14, c, d, e, f, g, h, a, b);
 301             T1 = X[15] = W[15];
 302             ROUND_00_15(15, b, c, d, e, f, g, h, a);
 303
 304             data += SHA256_CBLOCK;
 305         } else {
 306             SHA_LONG l;
 307
 308             HOST_c2l(data, l);
 309             T1 = X[0] = l;
 310             ROUND_00_15(0, a, b, c, d, e, f, g, h);
 311             HOST_c2l(data, l);
 312             T1 = X[1] = l;
 313             ROUND_00_15(1, h, a, b, c, d, e, f, g);
 314             HOST_c2l(data, l);
 315             T1 = X[2] = l;
 316             ROUND_00_15(2, g, h, a, b, c, d, e, f);
 317             HOST_c2l(data, l);
 318             T1 = X[3] = l;
 319             ROUND_00_15(3, f, g, h, a, b, c, d, e);
 320             HOST_c2l(data, l);
 321             T1 = X[4] = l;
 322             ROUND_00_15(4, e, f, g, h, a, b, c, d);
 323             HOST_c2l(data, l);
 324             T1 = X[5] = l;
 325             ROUND_00_15(5, d, e, f, g, h, a, b, c);
 326             HOST_c2l(data, l);
 327             T1 = X[6] = l;
 328             ROUND_00_15(6, c, d, e, f, g, h, a, b);
 329             HOST_c2l(data, l);
 330             T1 = X[7] = l;
 331             ROUND_00_15(7, b, c, d, e, f, g, h, a);
 332             HOST_c2l(data, l);
 333             T1 = X[8] = l;
 334             ROUND_00_15(8, a, b, c, d, e, f, g, h);
 335             HOST_c2l(data, l);
 336             T1 = X[9] = l;
 337             ROUND_00_15(9, h, a, b, c, d, e, f, g);
 338             HOST_c2l(data, l);
 339             T1 = X[10] = l;
 340             ROUND_00_15(10, g, h, a, b, c, d, e, f);
 341             HOST_c2l(data, l);
 342             T1 = X[11] = l;
 343             ROUND_00_15(11, f, g, h, a, b, c, d, e);
 344             HOST_c2l(data, l);
 345             T1 = X[12] = l;
 346             ROUND_00_15(12, e, f, g, h, a, b, c, d);
 347             HOST_c2l(data, l);
 348             T1 = X[13] = l;
 349             ROUND_00_15(13, d, e, f, g, h, a, b, c);
 350             HOST_c2l(data, l);
 351             T1 = X[14] = l;
 352             ROUND_00_15(14, c, d, e, f, g, h, a, b);
 353             HOST_c2l(data, l);
 354             T1 = X[15] = l;
 355             ROUND_00_15(15, b, c, d, e, f, g, h, a);
 356         }
 357
 358         for (i = 16; i < 64; i += 8) {
 359             ROUND_16_63(i + 0, a, b, c, d, e, f, g, h, X);
 360             ROUND_16_63(i + 1, h, a, b, c, d, e, f, g, X);
 361             ROUND_16_63(i + 2, g, h, a, b, c, d, e, f, X);
 362             ROUND_16_63(i + 3, f, g, h, a, b, c, d, e, X);
 363             ROUND_16_63(i + 4, e, f, g, h, a, b, c, d, X);
 364             ROUND_16_63(i + 5, d, e, f, g, h, a, b, c, X);
 365             ROUND_16_63(i + 6, c, d, e, f, g, h, a, b, X);
 366             ROUND_16_63(i + 7, b, c, d, e, f, g, h, a, X);
 367         }
 368
 369         ctx->h[0] += a;
 370         ctx->h[1] += b;
 371         ctx->h[2] += c;
 372         ctx->h[3] += d;
 373         ctx->h[4] += e;
 374         ctx->h[5] += f;
 375         ctx->h[6] += g;
 376         ctx->h[7] += h;
 377
 378     }
 379 }
 380
 381 # endif
 382 #endif                         /* SHA256_ASM */