deps/lzma-16.04/C/Sha256.c

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