• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
Sha256_Init(CSha256 * p)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 
Sha256_WriteByteBlock(CSha256 * p)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 
Sha256_Update(CSha256 * p,const Byte * data,size_t size)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 
Sha256_Final(CSha256 * p,Byte * digest)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 }
249