|
1 /* crypto/sha/sha256.c */ |
|
2 /* ==================================================================== |
|
3 * Copyright (c) 2004 The OpenSSL Project. All rights reserved |
|
4 * according to the OpenSSL license [found here]. |
|
5 * ==================================================================== |
|
6 */ |
|
7 |
|
8 /* ==================================================================== |
|
9 * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved. |
|
10 * |
|
11 * Redistribution and use in source and binary forms, with or without |
|
12 * modification, are permitted provided that the following conditions |
|
13 * are met: |
|
14 * |
|
15 * 1. Redistributions of source code must retain the above copyright |
|
16 * notice, this list of conditions and the following disclaimer. |
|
17 * |
|
18 * 2. Redistributions in binary form must reproduce the above copyright |
|
19 * notice, this list of conditions and the following disclaimer in |
|
20 * the documentation and/or other materials provided with the |
|
21 * distribution. |
|
22 * |
|
23 * 3. All advertising materials mentioning features or use of this |
|
24 * software must display the following acknowledgment: |
|
25 * "This product includes software developed by the OpenSSL Project |
|
26 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" |
|
27 * |
|
28 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|
29 * endorse or promote products derived from this software without |
|
30 * prior written permission. For written permission, please contact |
|
31 * openssl-core@openssl.org. |
|
32 * |
|
33 * 5. Products derived from this software may not be called "OpenSSL" |
|
34 * nor may "OpenSSL" appear in their names without prior written |
|
35 * permission of the OpenSSL Project. |
|
36 * |
|
37 * 6. Redistributions of any form whatsoever must retain the following |
|
38 * acknowledgment: |
|
39 * "This product includes software developed by the OpenSSL Project |
|
40 * for use in the OpenSSL Toolkit (http://www.openssl.org/)" |
|
41 * |
|
42 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|
43 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
44 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|
45 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|
46 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
47 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|
48 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|
49 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|
50 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|
51 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|
52 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|
53 * OF THE POSSIBILITY OF SUCH DAMAGE. |
|
54 * ==================================================================== |
|
55 * |
|
56 * This product includes cryptographic software written by Eric Young |
|
57 * (eay@cryptsoft.com). This product includes software written by Tim |
|
58 * Hudson (tjh@cryptsoft.com). |
|
59 * |
|
60 */ |
|
61 |
|
62 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
|
63 * All rights reserved. |
|
64 * |
|
65 * This package is an SSL implementation written |
|
66 * by Eric Young (eay@cryptsoft.com). |
|
67 * The implementation was written so as to conform with Netscapes SSL. |
|
68 * |
|
69 * This library is free for commercial and non-commercial use as long as |
|
70 * the following conditions are aheared to. The following conditions |
|
71 * apply to all code found in this distribution, be it the RC4, RSA, |
|
72 * lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|
73 * included with this distribution is covered by the same copyright terms |
|
74 * except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|
75 * |
|
76 * Copyright remains Eric Young's, and as such any Copyright notices in |
|
77 * the code are not to be removed. |
|
78 * If this package is used in a product, Eric Young should be given attribution |
|
79 * as the author of the parts of the library used. |
|
80 * This can be in the form of a textual message at program startup or |
|
81 * in documentation (online or textual) provided with the package. |
|
82 * |
|
83 * Redistribution and use in source and binary forms, with or without |
|
84 * modification, are permitted provided that the following conditions |
|
85 * are met: |
|
86 * 1. Redistributions of source code must retain the copyright |
|
87 * notice, this list of conditions and the following disclaimer. |
|
88 * 2. Redistributions in binary form must reproduce the above copyright |
|
89 * notice, this list of conditions and the following disclaimer in the |
|
90 * documentation and/or other materials provided with the distribution. |
|
91 * 3. All advertising materials mentioning features or use of this software |
|
92 * must display the following acknowledgement: |
|
93 * "This product includes cryptographic software written by |
|
94 * Eric Young (eay@cryptsoft.com)" |
|
95 * The word 'cryptographic' can be left out if the rouines from the library |
|
96 * being used are not cryptographic related :-). |
|
97 * 4. If you include any Windows specific code (or a derivative thereof) from |
|
98 * the apps directory (application code) you must include an acknowledgement: |
|
99 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|
100 * |
|
101 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|
102 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
103 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|
104 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|
105 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|
106 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|
107 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|
108 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|
109 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|
110 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|
111 * SUCH DAMAGE. |
|
112 * |
|
113 * The licence and distribution terms for any publically available version or |
|
114 * derivative of this code cannot be changed. i.e. this code cannot simply be |
|
115 * copied and put under another distribution licence |
|
116 * [including the GNU Public Licence.] |
|
117 */ |
|
118 /* |
|
119 © Portions copyright (c) 2010 Nokia Corporation. All rights reserved. |
|
120 */ |
|
121 |
|
122 #include <openssl/opensslconf.h> |
|
123 #if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_SHA256) |
|
124 |
|
125 #include <stdlib.h> |
|
126 #include <string.h> |
|
127 |
|
128 #include <openssl/crypto.h> |
|
129 #include <openssl/sha.h> |
|
130 #include <openssl/opensslv.h> |
|
131 |
|
132 const char SHA256_version[]="SHA-256" OPENSSL_VERSION_PTEXT; |
|
133 |
|
134 EXPORT_C int SHA224_Init (SHA256_CTX *c) |
|
135 { |
|
136 c->h[0]=0xc1059ed8UL; c->h[1]=0x367cd507UL; |
|
137 c->h[2]=0x3070dd17UL; c->h[3]=0xf70e5939UL; |
|
138 c->h[4]=0xffc00b31UL; c->h[5]=0x68581511UL; |
|
139 c->h[6]=0x64f98fa7UL; c->h[7]=0xbefa4fa4UL; |
|
140 c->Nl=0; c->Nh=0; |
|
141 c->num=0; c->md_len=SHA224_DIGEST_LENGTH; |
|
142 return 1; |
|
143 } |
|
144 |
|
145 EXPORT_C int SHA256_Init (SHA256_CTX *c) |
|
146 { |
|
147 c->h[0]=0x6a09e667UL; c->h[1]=0xbb67ae85UL; |
|
148 c->h[2]=0x3c6ef372UL; c->h[3]=0xa54ff53aUL; |
|
149 c->h[4]=0x510e527fUL; c->h[5]=0x9b05688cUL; |
|
150 c->h[6]=0x1f83d9abUL; c->h[7]=0x5be0cd19UL; |
|
151 c->Nl=0; c->Nh=0; |
|
152 c->num=0; c->md_len=SHA256_DIGEST_LENGTH; |
|
153 return 1; |
|
154 } |
|
155 |
|
156 EXPORT_C unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md) |
|
157 { |
|
158 SHA256_CTX c; |
|
159 static unsigned char m[SHA224_DIGEST_LENGTH]; |
|
160 |
|
161 if (md == NULL) md=m; |
|
162 SHA224_Init(&c); |
|
163 SHA256_Update(&c,d,n); |
|
164 SHA256_Final(md,&c); |
|
165 OPENSSL_cleanse(&c,sizeof(c)); |
|
166 return(md); |
|
167 } |
|
168 |
|
169 EXPORT_C unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md) |
|
170 { |
|
171 SHA256_CTX c; |
|
172 static unsigned char m[SHA256_DIGEST_LENGTH]; |
|
173 |
|
174 if (md == NULL) md=m; |
|
175 SHA256_Init(&c); |
|
176 SHA256_Update(&c,d,n); |
|
177 SHA256_Final(md,&c); |
|
178 OPENSSL_cleanse(&c,sizeof(c)); |
|
179 return(md); |
|
180 } |
|
181 |
|
182 EXPORT_C int SHA224_Update(SHA256_CTX *c, const void *data, size_t len) |
|
183 { return SHA256_Update (c,data,len); } |
|
184 EXPORT_C int SHA224_Final (unsigned char *md, SHA256_CTX *c) |
|
185 { return SHA256_Final (md,c); } |
|
186 |
|
187 #ifndef SHA_LONG_LOG2 |
|
188 #define SHA_LONG_LOG2 2 /* default to 32 bits */ |
|
189 #endif |
|
190 |
|
191 #define DATA_ORDER_IS_BIG_ENDIAN |
|
192 |
|
193 #define HASH_LONG SHA_LONG |
|
194 #define HASH_LONG_LOG2 SHA_LONG_LOG2 |
|
195 #define HASH_CTX SHA256_CTX |
|
196 #define HASH_CBLOCK SHA_CBLOCK |
|
197 #define HASH_LBLOCK SHA_LBLOCK |
|
198 /* |
|
199 * Note that FIPS180-2 discusses "Truncation of the Hash Function Output." |
|
200 * default: case below covers for it. It's not clear however if it's |
|
201 * permitted to truncate to amount of bytes not divisible by 4. I bet not, |
|
202 * but if it is, then default: case shall be extended. For reference. |
|
203 * Idea behind separate cases for pre-defined lenghts is to let the |
|
204 * compiler decide if it's appropriate to unroll small loops. |
|
205 */ |
|
206 #define HASH_MAKE_STRING(c,s) do { \ |
|
207 unsigned long ll; \ |
|
208 unsigned int n; \ |
|
209 switch ((c)->md_len) \ |
|
210 { case SHA224_DIGEST_LENGTH: \ |
|
211 for (n=0;n<SHA224_DIGEST_LENGTH/4;n++) \ |
|
212 { ll=(c)->h[n]; HOST_l2c(ll,(s)); } \ |
|
213 break; \ |
|
214 case SHA256_DIGEST_LENGTH: \ |
|
215 for (n=0;n<SHA256_DIGEST_LENGTH/4;n++) \ |
|
216 { ll=(c)->h[n]; HOST_l2c(ll,(s)); } \ |
|
217 break; \ |
|
218 default: \ |
|
219 if ((c)->md_len > SHA256_DIGEST_LENGTH) \ |
|
220 return 0; \ |
|
221 for (n=0;n<(c)->md_len/4;n++) \ |
|
222 { ll=(c)->h[n]; HOST_l2c(ll,(s)); } \ |
|
223 break; \ |
|
224 } \ |
|
225 } while (0) |
|
226 |
|
227 #define HASH_UPDATE SHA256_Update |
|
228 #define HASH_TRANSFORM SHA256_Transform |
|
229 #define HASH_FINAL SHA256_Final |
|
230 #define HASH_BLOCK_HOST_ORDER sha256_block_host_order |
|
231 #define HASH_BLOCK_DATA_ORDER sha256_block_data_order |
|
232 void sha256_block_host_order (SHA256_CTX *ctx, const void *in, size_t num); |
|
233 void sha256_block_data_order (SHA256_CTX *ctx, const void *in, size_t num); |
|
234 |
|
235 #include "md32_common.h" |
|
236 |
|
237 #ifdef SHA256_ASM |
|
238 void sha256_block (SHA256_CTX *ctx, const void *in, size_t num, int host); |
|
239 #else |
|
240 static const SHA_LONG K256[64] = { |
|
241 0x428a2f98UL,0x71374491UL,0xb5c0fbcfUL,0xe9b5dba5UL, |
|
242 0x3956c25bUL,0x59f111f1UL,0x923f82a4UL,0xab1c5ed5UL, |
|
243 0xd807aa98UL,0x12835b01UL,0x243185beUL,0x550c7dc3UL, |
|
244 0x72be5d74UL,0x80deb1feUL,0x9bdc06a7UL,0xc19bf174UL, |
|
245 0xe49b69c1UL,0xefbe4786UL,0x0fc19dc6UL,0x240ca1ccUL, |
|
246 0x2de92c6fUL,0x4a7484aaUL,0x5cb0a9dcUL,0x76f988daUL, |
|
247 0x983e5152UL,0xa831c66dUL,0xb00327c8UL,0xbf597fc7UL, |
|
248 0xc6e00bf3UL,0xd5a79147UL,0x06ca6351UL,0x14292967UL, |
|
249 0x27b70a85UL,0x2e1b2138UL,0x4d2c6dfcUL,0x53380d13UL, |
|
250 0x650a7354UL,0x766a0abbUL,0x81c2c92eUL,0x92722c85UL, |
|
251 0xa2bfe8a1UL,0xa81a664bUL,0xc24b8b70UL,0xc76c51a3UL, |
|
252 0xd192e819UL,0xd6990624UL,0xf40e3585UL,0x106aa070UL, |
|
253 0x19a4c116UL,0x1e376c08UL,0x2748774cUL,0x34b0bcb5UL, |
|
254 0x391c0cb3UL,0x4ed8aa4aUL,0x5b9cca4fUL,0x682e6ff3UL, |
|
255 0x748f82eeUL,0x78a5636fUL,0x84c87814UL,0x8cc70208UL, |
|
256 0x90befffaUL,0xa4506cebUL,0xbef9a3f7UL,0xc67178f2UL }; |
|
257 |
|
258 /* |
|
259 * FIPS specification refers to right rotations, while our ROTATE macro |
|
260 * is left one. This is why you might notice that rotation coefficients |
|
261 * differ from those observed in FIPS document by 32-N... |
|
262 */ |
|
263 #define Sigma0(x) (ROTATE((x),30) ^ ROTATE((x),19) ^ ROTATE((x),10)) |
|
264 #define Sigma1(x) (ROTATE((x),26) ^ ROTATE((x),21) ^ ROTATE((x),7)) |
|
265 #define sigma0(x) (ROTATE((x),25) ^ ROTATE((x),14) ^ ((x)>>3)) |
|
266 #define sigma1(x) (ROTATE((x),15) ^ ROTATE((x),13) ^ ((x)>>10)) |
|
267 |
|
268 #define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z))) |
|
269 #define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) |
|
270 |
|
271 #ifdef OPENSSL_SMALL_FOOTPRINT |
|
272 |
|
273 static void sha256_block (SHA256_CTX *ctx, const void *in, size_t num, int host) |
|
274 { |
|
275 unsigned MD32_REG_T a,b,c,d,e,f,g,h,s0,s1,T1,T2; |
|
276 SHA_LONG X[16]; |
|
277 int i; |
|
278 const unsigned char *data=in; |
|
279 |
|
280 while (num--) { |
|
281 |
|
282 a = ctx->h[0]; b = ctx->h[1]; c = ctx->h[2]; d = ctx->h[3]; |
|
283 e = ctx->h[4]; f = ctx->h[5]; g = ctx->h[6]; h = ctx->h[7]; |
|
284 |
|
285 if (host) |
|
286 { |
|
287 const SHA_LONG *W=(const SHA_LONG *)data; |
|
288 |
|
289 for (i=0;i<16;i++) |
|
290 { |
|
291 T1 = X[i] = W[i]; |
|
292 T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i]; |
|
293 T2 = Sigma0(a) + Maj(a,b,c); |
|
294 h = g; g = f; f = e; e = d + T1; |
|
295 d = c; c = b; b = a; a = T1 + T2; |
|
296 } |
|
297 |
|
298 data += SHA256_CBLOCK; |
|
299 } |
|
300 else |
|
301 { |
|
302 SHA_LONG l; |
|
303 |
|
304 for (i=0;i<16;i++) |
|
305 { |
|
306 HOST_c2l(data,l); T1 = X[i] = l; |
|
307 T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i]; |
|
308 T2 = Sigma0(a) + Maj(a,b,c); |
|
309 h = g; g = f; f = e; e = d + T1; |
|
310 d = c; c = b; b = a; a = T1 + T2; |
|
311 } |
|
312 } |
|
313 |
|
314 for (;i<64;i++) |
|
315 { |
|
316 s0 = X[(i+1)&0x0f]; s0 = sigma0(s0); |
|
317 s1 = X[(i+14)&0x0f]; s1 = sigma1(s1); |
|
318 |
|
319 T1 = X[i&0xf] += s0 + s1 + X[(i+9)&0xf]; |
|
320 T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i]; |
|
321 T2 = Sigma0(a) + Maj(a,b,c); |
|
322 h = g; g = f; f = e; e = d + T1; |
|
323 d = c; c = b; b = a; a = T1 + T2; |
|
324 } |
|
325 |
|
326 ctx->h[0] += a; ctx->h[1] += b; ctx->h[2] += c; ctx->h[3] += d; |
|
327 ctx->h[4] += e; ctx->h[5] += f; ctx->h[6] += g; ctx->h[7] += h; |
|
328 |
|
329 } |
|
330 } |
|
331 |
|
332 #else |
|
333 |
|
334 #define ROUND_00_15(i,a,b,c,d,e,f,g,h) do { \ |
|
335 T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i]; \ |
|
336 h = Sigma0(a) + Maj(a,b,c); \ |
|
337 d += T1; h += T1; } while (0) |
|
338 |
|
339 #define ROUND_16_63(i,a,b,c,d,e,f,g,h,X) do { \ |
|
340 s0 = X[(i+1)&0x0f]; s0 = sigma0(s0); \ |
|
341 s1 = X[(i+14)&0x0f]; s1 = sigma1(s1); \ |
|
342 T1 = X[(i)&0x0f] += s0 + s1 + X[(i+9)&0x0f]; \ |
|
343 ROUND_00_15(i,a,b,c,d,e,f,g,h); } while (0) |
|
344 |
|
345 static void sha256_block (SHA256_CTX *ctx, const void *in, size_t num, int host) |
|
346 { |
|
347 unsigned MD32_REG_T a,b,c,d,e,f,g,h,s0,s1,T1; |
|
348 SHA_LONG X[16]; |
|
349 int i; |
|
350 const unsigned char *data=in; |
|
351 |
|
352 while (num--) { |
|
353 |
|
354 a = ctx->h[0]; b = ctx->h[1]; c = ctx->h[2]; d = ctx->h[3]; |
|
355 e = ctx->h[4]; f = ctx->h[5]; g = ctx->h[6]; h = ctx->h[7]; |
|
356 |
|
357 if (host) |
|
358 { |
|
359 const SHA_LONG *W=(const SHA_LONG *)data; |
|
360 |
|
361 T1 = X[0] = W[0]; ROUND_00_15(0,a,b,c,d,e,f,g,h); |
|
362 T1 = X[1] = W[1]; ROUND_00_15(1,h,a,b,c,d,e,f,g); |
|
363 T1 = X[2] = W[2]; ROUND_00_15(2,g,h,a,b,c,d,e,f); |
|
364 T1 = X[3] = W[3]; ROUND_00_15(3,f,g,h,a,b,c,d,e); |
|
365 T1 = X[4] = W[4]; ROUND_00_15(4,e,f,g,h,a,b,c,d); |
|
366 T1 = X[5] = W[5]; ROUND_00_15(5,d,e,f,g,h,a,b,c); |
|
367 T1 = X[6] = W[6]; ROUND_00_15(6,c,d,e,f,g,h,a,b); |
|
368 T1 = X[7] = W[7]; ROUND_00_15(7,b,c,d,e,f,g,h,a); |
|
369 T1 = X[8] = W[8]; ROUND_00_15(8,a,b,c,d,e,f,g,h); |
|
370 T1 = X[9] = W[9]; ROUND_00_15(9,h,a,b,c,d,e,f,g); |
|
371 T1 = X[10] = W[10]; ROUND_00_15(10,g,h,a,b,c,d,e,f); |
|
372 T1 = X[11] = W[11]; ROUND_00_15(11,f,g,h,a,b,c,d,e); |
|
373 T1 = X[12] = W[12]; ROUND_00_15(12,e,f,g,h,a,b,c,d); |
|
374 T1 = X[13] = W[13]; ROUND_00_15(13,d,e,f,g,h,a,b,c); |
|
375 T1 = X[14] = W[14]; ROUND_00_15(14,c,d,e,f,g,h,a,b); |
|
376 T1 = X[15] = W[15]; ROUND_00_15(15,b,c,d,e,f,g,h,a); |
|
377 |
|
378 data += SHA256_CBLOCK; |
|
379 } |
|
380 else |
|
381 { |
|
382 SHA_LONG l; |
|
383 |
|
384 HOST_c2l(data,l); T1 = X[0] = l; ROUND_00_15(0,a,b,c,d,e,f,g,h); |
|
385 HOST_c2l(data,l); T1 = X[1] = l; ROUND_00_15(1,h,a,b,c,d,e,f,g); |
|
386 HOST_c2l(data,l); T1 = X[2] = l; ROUND_00_15(2,g,h,a,b,c,d,e,f); |
|
387 HOST_c2l(data,l); T1 = X[3] = l; ROUND_00_15(3,f,g,h,a,b,c,d,e); |
|
388 HOST_c2l(data,l); T1 = X[4] = l; ROUND_00_15(4,e,f,g,h,a,b,c,d); |
|
389 HOST_c2l(data,l); T1 = X[5] = l; ROUND_00_15(5,d,e,f,g,h,a,b,c); |
|
390 HOST_c2l(data,l); T1 = X[6] = l; ROUND_00_15(6,c,d,e,f,g,h,a,b); |
|
391 HOST_c2l(data,l); T1 = X[7] = l; ROUND_00_15(7,b,c,d,e,f,g,h,a); |
|
392 HOST_c2l(data,l); T1 = X[8] = l; ROUND_00_15(8,a,b,c,d,e,f,g,h); |
|
393 HOST_c2l(data,l); T1 = X[9] = l; ROUND_00_15(9,h,a,b,c,d,e,f,g); |
|
394 HOST_c2l(data,l); T1 = X[10] = l; ROUND_00_15(10,g,h,a,b,c,d,e,f); |
|
395 HOST_c2l(data,l); T1 = X[11] = l; ROUND_00_15(11,f,g,h,a,b,c,d,e); |
|
396 HOST_c2l(data,l); T1 = X[12] = l; ROUND_00_15(12,e,f,g,h,a,b,c,d); |
|
397 HOST_c2l(data,l); T1 = X[13] = l; ROUND_00_15(13,d,e,f,g,h,a,b,c); |
|
398 HOST_c2l(data,l); T1 = X[14] = l; ROUND_00_15(14,c,d,e,f,g,h,a,b); |
|
399 HOST_c2l(data,l); T1 = X[15] = l; ROUND_00_15(15,b,c,d,e,f,g,h,a); |
|
400 } |
|
401 |
|
402 for (i=16;i<64;i+=8) |
|
403 { |
|
404 ROUND_16_63(i+0,a,b,c,d,e,f,g,h,X); |
|
405 ROUND_16_63(i+1,h,a,b,c,d,e,f,g,X); |
|
406 ROUND_16_63(i+2,g,h,a,b,c,d,e,f,X); |
|
407 ROUND_16_63(i+3,f,g,h,a,b,c,d,e,X); |
|
408 ROUND_16_63(i+4,e,f,g,h,a,b,c,d,X); |
|
409 ROUND_16_63(i+5,d,e,f,g,h,a,b,c,X); |
|
410 ROUND_16_63(i+6,c,d,e,f,g,h,a,b,X); |
|
411 ROUND_16_63(i+7,b,c,d,e,f,g,h,a,X); |
|
412 } |
|
413 |
|
414 ctx->h[0] += a; ctx->h[1] += b; ctx->h[2] += c; ctx->h[3] += d; |
|
415 ctx->h[4] += e; ctx->h[5] += f; ctx->h[6] += g; ctx->h[7] += h; |
|
416 |
|
417 } |
|
418 } |
|
419 |
|
420 #endif |
|
421 #endif /* SHA256_ASM */ |
|
422 |
|
423 /* |
|
424 * Idea is to trade couple of cycles for some space. On IA-32 we save |
|
425 * about 4K in "big footprint" case. In "small footprint" case any gain |
|
426 * is appreciated:-) |
|
427 */ |
|
428 void HASH_BLOCK_HOST_ORDER (SHA256_CTX *ctx, const void *in, size_t num) |
|
429 { sha256_block (ctx,in,num,1); } |
|
430 |
|
431 void HASH_BLOCK_DATA_ORDER (SHA256_CTX *ctx, const void *in, size_t num) |
|
432 { sha256_block (ctx,in,num,0); } |
|
433 |
|
434 #endif /* OPENSSL_NO_SHA256 */ |