tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

Sha256.c (5545B)

      1 /* Crypto/Sha256.c -- SHA-256 Hash
      2 2017-04-03 : Igor Pavlov : Public domain
      3 This code is based on public domain code from Wei Dai's Crypto++ library. */
      4 
      5 #include "Precomp.h"
      6 
      7 #include <string.h>
      8 
      9 #include "CpuArch.h"
     10 #include "RotateDefs.h"
     11 #include "Sha256.h"
     12 
     13 /* define it for speed optimization */
     14 #ifndef _SFX
     15 #define _SHA256_UNROLL
     16 #define _SHA256_UNROLL2
     17 #endif
     18 
     19 /* #define _SHA256_UNROLL2 */
     20 
     21 void Sha256_Init(CSha256 *p)
     22 {
     23  p->state[0] = 0x6a09e667;
     24  p->state[1] = 0xbb67ae85;
     25  p->state[2] = 0x3c6ef372;
     26  p->state[3] = 0xa54ff53a;
     27  p->state[4] = 0x510e527f;
     28  p->state[5] = 0x9b05688c;
     29  p->state[6] = 0x1f83d9ab;
     30  p->state[7] = 0x5be0cd19;
     31  p->count = 0;
     32 }
     33 
     34 #define S0(x) (rotrFixed(x, 2) ^ rotrFixed(x,13) ^ rotrFixed(x, 22))
     35 #define S1(x) (rotrFixed(x, 6) ^ rotrFixed(x,11) ^ rotrFixed(x, 25))
     36 #define s0(x) (rotrFixed(x, 7) ^ rotrFixed(x,18) ^ (x >> 3))
     37 #define s1(x) (rotrFixed(x,17) ^ rotrFixed(x,19) ^ (x >> 10))
     38 
     39 #define blk0(i) (W[i])
     40 #define blk2(i) (W[i] += s1(W[((i)-2)&15]) + W[((i)-7)&15] + s0(W[((i)-15)&15]))
     41 
     42 #define Ch(x,y,z) (z^(x&(y^z)))
     43 #define Maj(x,y,z) ((x&y)|(z&(x|y)))
     44 
     45 #ifdef _SHA256_UNROLL2
     46 
     47 #define R(a,b,c,d,e,f,g,h, i) \
     48    h += S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + (j ? blk2(i) : blk0(i)); \
     49    d += h; \
     50    h += S0(a) + Maj(a, b, c)
     51 
     52 #define RX_8(i) \
     53  R(a,b,c,d,e,f,g,h, i); \
     54  R(h,a,b,c,d,e,f,g, i+1); \
     55  R(g,h,a,b,c,d,e,f, i+2); \
     56  R(f,g,h,a,b,c,d,e, i+3); \
     57  R(e,f,g,h,a,b,c,d, i+4); \
     58  R(d,e,f,g,h,a,b,c, i+5); \
     59  R(c,d,e,f,g,h,a,b, i+6); \
     60  R(b,c,d,e,f,g,h,a, i+7)
     61 
     62 #define RX_16  RX_8(0); RX_8(8);
     63 
     64 #else
     65 
     66 #define a(i) T[(0-(i))&7]
     67 #define b(i) T[(1-(i))&7]
     68 #define c(i) T[(2-(i))&7]
     69 #define d(i) T[(3-(i))&7]
     70 #define e(i) T[(4-(i))&7]
     71 #define f(i) T[(5-(i))&7]
     72 #define g(i) T[(6-(i))&7]
     73 #define h(i) T[(7-(i))&7]
     74 
     75 #define R(i) \
     76    h(i) += S1(e(i)) + Ch(e(i),f(i),g(i)) + K[(i)+(size_t)(j)] + (j ? blk2(i) : blk0(i)); \
     77    d(i) += h(i); \
     78    h(i) += S0(a(i)) + Maj(a(i), b(i), c(i)) \
     79 
     80 #ifdef _SHA256_UNROLL
     81 
     82 #define RX_8(i)  R(i+0); R(i+1); R(i+2); R(i+3); R(i+4); R(i+5); R(i+6); R(i+7);
     83 #define RX_16  RX_8(0); RX_8(8);
     84 
     85 #else
     86 
     87 #define RX_16  unsigned i; for (i = 0; i < 16; i++) { R(i); }
     88 
     89 #endif
     90 
     91 #endif
     92 
     93 static const UInt32 K[64] = {
     94  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
     95  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
     96  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
     97  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
     98  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
     99  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
    100  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
    101  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
    102  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
    103  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
    104  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
    105  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
    106  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
    107  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
    108  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
    109  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
    110 };
    111 
    112 static void Sha256_WriteByteBlock(CSha256 *p)
    113 {
    114  UInt32 W[16];
    115  unsigned j;
    116  UInt32 *state;
    117 
    118  #ifdef _SHA256_UNROLL2
    119  UInt32 a,b,c,d,e,f,g,h;
    120  #else
    121  UInt32 T[8];
    122  #endif
    123 
    124  for (j = 0; j < 16; j += 4)
    125  {
    126    const Byte *ccc = p->buffer + j * 4;
    127    W[j    ] = GetBe32(ccc);
    128    W[j + 1] = GetBe32(ccc + 4);
    129    W[j + 2] = GetBe32(ccc + 8);
    130    W[j + 3] = GetBe32(ccc + 12);
    131  }
    132 
    133  state = p->state;
    134 
    135  #ifdef _SHA256_UNROLL2
    136  a = state[0];
    137  b = state[1];
    138  c = state[2];
    139  d = state[3];
    140  e = state[4];
    141  f = state[5];
    142  g = state[6];
    143  h = state[7];
    144  #else
    145  for (j = 0; j < 8; j++)
    146    T[j] = state[j];
    147  #endif
    148 
    149  for (j = 0; j < 64; j += 16)
    150  {
    151    RX_16
    152  }
    153 
    154  #ifdef _SHA256_UNROLL2
    155  state[0] += a;
    156  state[1] += b;
    157  state[2] += c;
    158  state[3] += d;
    159  state[4] += e;
    160  state[5] += f;
    161  state[6] += g;
    162  state[7] += h;
    163  #else
    164  for (j = 0; j < 8; j++)
    165    state[j] += T[j];
    166  #endif
    167  
    168  /* Wipe variables */
    169  /* memset(W, 0, sizeof(W)); */
    170  /* memset(T, 0, sizeof(T)); */
    171 }
    172 
    173 #undef S0
    174 #undef S1
    175 #undef s0
    176 #undef s1
    177 
    178 void Sha256_Update(CSha256 *p, const Byte *data, size_t size)
    179 {
    180  if (size == 0)
    181    return;
    182 
    183  {
    184    unsigned pos = (unsigned)p->count & 0x3F;
    185    unsigned num;
    186    
    187    p->count += size;
    188    
    189    num = 64 - pos;
    190    if (num > size)
    191    {
    192      memcpy(p->buffer + pos, data, size);
    193      return;
    194    }
    195    
    196    size -= num;
    197    memcpy(p->buffer + pos, data, num);
    198    data += num;
    199  }
    200 
    201  for (;;)
    202  {
    203    Sha256_WriteByteBlock(p);
    204    if (size < 64)
    205      break;
    206    size -= 64;
    207    memcpy(p->buffer, data, 64);
    208    data += 64;
    209  }
    210 
    211  if (size != 0)
    212    memcpy(p->buffer, data, size);
    213 }
    214 
    215 void Sha256_Final(CSha256 *p, Byte *digest)
    216 {
    217  unsigned pos = (unsigned)p->count & 0x3F;
    218  unsigned i;
    219  
    220  p->buffer[pos++] = 0x80;
    221  
    222  while (pos != (64 - 8))
    223  {
    224    pos &= 0x3F;
    225    if (pos == 0)
    226      Sha256_WriteByteBlock(p);
    227    p->buffer[pos++] = 0;
    228  }
    229 
    230  {
    231    UInt64 numBits = (p->count << 3);
    232    SetBe32(p->buffer + 64 - 8, (UInt32)(numBits >> 32));
    233    SetBe32(p->buffer + 64 - 4, (UInt32)(numBits));
    234  }
    235  
    236  Sha256_WriteByteBlock(p);
    237 
    238  for (i = 0; i < 8; i += 2)
    239  {
    240    UInt32 v0 = p->state[i];
    241    UInt32 v1 = p->state[i + 1];
    242    SetBe32(digest    , v0);
    243    SetBe32(digest + 4, v1);
    244    digest += 8;
    245  }
    246  
    247  Sha256_Init(p);
    248 }