C/Sha256.c

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