?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MINI2440: Auto probe for SDRAM size
[u-boot-openmoko/mini2440.git] / lib_generic / sha1.c
blob08ffa6b9bacb43382535b664e08334c0c84ae005
1 /*
2 * Heiko Schocher, DENX Software Engineering, hs@denx.de.
3 * based on:
4 * FIPS-180-1 compliant SHA-1 implementation
5 *
6 * Copyright (C) 2003-2006 Christophe Devine
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License, version 2.1 as published by the Free Software Foundation.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
20 * MA 02110-1301 USA
21 */
22 /*
23 * The SHA-1 standard was published by NIST in 1993.
24 *
25 * http://www.itl.nist.gov/fipspubs/fip180-1.htm
26 */
27
28 #ifndef _CRT_SECURE_NO_DEPRECATE
29 #define _CRT_SECURE_NO_DEPRECATE 1
30 #endif
31
32 #include <linux/string.h>
33 #include "sha1.h"
34
35 /*
36 * 32-bit integer manipulation macros (big endian)
37 */
38 #ifndef GET_UINT32_BE
39 #define GET_UINT32_BE(n,b,i) { \
40 (n) = ( (unsigned long) (b)[(i) ] << 24 ) \
41 | ( (unsigned long) (b)[(i) + 1] << 16 ) \
42 | ( (unsigned long) (b)[(i) + 2] << 8 ) \
43 | ( (unsigned long) (b)[(i) + 3] ); \
44 }
45 #endif
46 #ifndef PUT_UINT32_BE
47 #define PUT_UINT32_BE(n,b,i) { \
48 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
49 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
50 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
51 (b)[(i) + 3] = (unsigned char) ( (n) ); \
52 }
53 #endif
54
55 /*
56 * SHA-1 context setup
57 */
58 void sha1_starts (sha1_context * ctx)
59 {
60 ctx->total[0] = 0;
61 ctx->total[1] = 0;
62
63 ctx->state[0] = 0x67452301;
64 ctx->state[1] = 0xEFCDAB89;
65 ctx->state[2] = 0x98BADCFE;
66 ctx->state[3] = 0x10325476;
67 ctx->state[4] = 0xC3D2E1F0;
68 }
69
70 static void sha1_process (sha1_context * ctx, unsigned char data[64])
71 {
72 unsigned long temp, W[16], A, B, C, D, E;
73
74 GET_UINT32_BE (W[0], data, 0);
75 GET_UINT32_BE (W[1], data, 4);
76 GET_UINT32_BE (W[2], data, 8);
77 GET_UINT32_BE (W[3], data, 12);
78 GET_UINT32_BE (W[4], data, 16);
79 GET_UINT32_BE (W[5], data, 20);
80 GET_UINT32_BE (W[6], data, 24);
81 GET_UINT32_BE (W[7], data, 28);
82 GET_UINT32_BE (W[8], data, 32);
83 GET_UINT32_BE (W[9], data, 36);
84 GET_UINT32_BE (W[10], data, 40);
85 GET_UINT32_BE (W[11], data, 44);
86 GET_UINT32_BE (W[12], data, 48);
87 GET_UINT32_BE (W[13], data, 52);
88 GET_UINT32_BE (W[14], data, 56);
89 GET_UINT32_BE (W[15], data, 60);
90
91 #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
92
93 #define R(t) ( \
94 temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ \
95 W[(t - 14) & 0x0F] ^ W[ t & 0x0F], \
96 ( W[t & 0x0F] = S(temp,1) ) \
97 )
98
99 #define P(a,b,c,d,e,x) { \
100 e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \
101 }
102
103 A = ctx->state[0];
104 B = ctx->state[1];
105 C = ctx->state[2];
106 D = ctx->state[3];
107 E = ctx->state[4];
108
109 #define F(x,y,z) (z ^ (x & (y ^ z)))
110 #define K 0x5A827999
111
112 P (A, B, C, D, E, W[0]);
113 P (E, A, B, C, D, W[1]);
114 P (D, E, A, B, C, W[2]);
115 P (C, D, E, A, B, W[3]);
116 P (B, C, D, E, A, W[4]);
117 P (A, B, C, D, E, W[5]);
118 P (E, A, B, C, D, W[6]);
119 P (D, E, A, B, C, W[7]);
120 P (C, D, E, A, B, W[8]);
121 P (B, C, D, E, A, W[9]);
122 P (A, B, C, D, E, W[10]);
123 P (E, A, B, C, D, W[11]);
124 P (D, E, A, B, C, W[12]);
125 P (C, D, E, A, B, W[13]);
126 P (B, C, D, E, A, W[14]);
127 P (A, B, C, D, E, W[15]);
128 P (E, A, B, C, D, R (16));
129 P (D, E, A, B, C, R (17));
130 P (C, D, E, A, B, R (18));
131 P (B, C, D, E, A, R (19));
132
133 #undef K
134 #undef F
135
136 #define F(x,y,z) (x ^ y ^ z)
137 #define K 0x6ED9EBA1
138
139 P (A, B, C, D, E, R (20));
140 P (E, A, B, C, D, R (21));
141 P (D, E, A, B, C, R (22));
142 P (C, D, E, A, B, R (23));
143 P (B, C, D, E, A, R (24));
144 P (A, B, C, D, E, R (25));
145 P (E, A, B, C, D, R (26));
146 P (D, E, A, B, C, R (27));
147 P (C, D, E, A, B, R (28));
148 P (B, C, D, E, A, R (29));
149 P (A, B, C, D, E, R (30));
150 P (E, A, B, C, D, R (31));
151 P (D, E, A, B, C, R (32));
152 P (C, D, E, A, B, R (33));
153 P (B, C, D, E, A, R (34));
154 P (A, B, C, D, E, R (35));
155 P (E, A, B, C, D, R (36));
156 P (D, E, A, B, C, R (37));
157 P (C, D, E, A, B, R (38));
158 P (B, C, D, E, A, R (39));
159
160 #undef K
161 #undef F
162
163 #define F(x,y,z) ((x & y) | (z & (x | y)))
164 #define K 0x8F1BBCDC
165
166 P (A, B, C, D, E, R (40));
167 P (E, A, B, C, D, R (41));
168 P (D, E, A, B, C, R (42));
169 P (C, D, E, A, B, R (43));
170 P (B, C, D, E, A, R (44));
171 P (A, B, C, D, E, R (45));
172 P (E, A, B, C, D, R (46));
173 P (D, E, A, B, C, R (47));
174 P (C, D, E, A, B, R (48));
175 P (B, C, D, E, A, R (49));
176 P (A, B, C, D, E, R (50));
177 P (E, A, B, C, D, R (51));
178 P (D, E, A, B, C, R (52));
179 P (C, D, E, A, B, R (53));
180 P (B, C, D, E, A, R (54));
181 P (A, B, C, D, E, R (55));
182 P (E, A, B, C, D, R (56));
183 P (D, E, A, B, C, R (57));
184 P (C, D, E, A, B, R (58));
185 P (B, C, D, E, A, R (59));
186
187 #undef K
188 #undef F
189
190 #define F(x,y,z) (x ^ y ^ z)
191 #define K 0xCA62C1D6
192
193 P (A, B, C, D, E, R (60));
194 P (E, A, B, C, D, R (61));
195 P (D, E, A, B, C, R (62));
196 P (C, D, E, A, B, R (63));
197 P (B, C, D, E, A, R (64));
198 P (A, B, C, D, E, R (65));
199 P (E, A, B, C, D, R (66));
200 P (D, E, A, B, C, R (67));
201 P (C, D, E, A, B, R (68));
202 P (B, C, D, E, A, R (69));
203 P (A, B, C, D, E, R (70));
204 P (E, A, B, C, D, R (71));
205 P (D, E, A, B, C, R (72));
206 P (C, D, E, A, B, R (73));
207 P (B, C, D, E, A, R (74));
208 P (A, B, C, D, E, R (75));
209 P (E, A, B, C, D, R (76));
210 P (D, E, A, B, C, R (77));
211 P (C, D, E, A, B, R (78));
212 P (B, C, D, E, A, R (79));
213
214 #undef K
215 #undef F
216
217 ctx->state[0] += A;
218 ctx->state[1] += B;
219 ctx->state[2] += C;
220 ctx->state[3] += D;
221 ctx->state[4] += E;
222 }
223
224 /*
225 * SHA-1 process buffer
226 */
227 void sha1_update (sha1_context * ctx, unsigned char *input, int ilen)
228 {
229 int fill;
230 unsigned long left;
231
232 if (ilen <= 0)
233 return;
234
235 left = ctx->total[0] & 0x3F;
236 fill = 64 - left;
237
238 ctx->total[0] += ilen;
239 ctx->total[0] &= 0xFFFFFFFF;
240
241 if (ctx->total[0] < (unsigned long) ilen)
242 ctx->total[1]++;
243
244 if (left && ilen >= fill) {
245 memcpy ((void *) (ctx->buffer + left), (void *) input, fill);
246 sha1_process (ctx, ctx->buffer);
247 input += fill;
248 ilen -= fill;
249 left = 0;
250 }
251
252 while (ilen >= 64) {
253 sha1_process (ctx, input);
254 input += 64;
255 ilen -= 64;
256 }
257
258 if (ilen > 0) {
259 memcpy ((void *) (ctx->buffer + left), (void *) input, ilen);
260 }
261 }
262
263 static const unsigned char sha1_padding[64] = {
264 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
265 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
266 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
267 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
268 };
269
270 /*
271 * SHA-1 final digest
272 */
273 void sha1_finish (sha1_context * ctx, unsigned char output[20])
274 {
275 unsigned long last, padn;
276 unsigned long high, low;
277 unsigned char msglen[8];
278
279 high = (ctx->total[0] >> 29)
280 | (ctx->total[1] << 3);
281 low = (ctx->total[0] << 3);
282
283 PUT_UINT32_BE (high, msglen, 0);
284 PUT_UINT32_BE (low, msglen, 4);
285
286 last = ctx->total[0] & 0x3F;
287 padn = (last < 56) ? (56 - last) : (120 - last);
288
289 sha1_update (ctx, (unsigned char *) sha1_padding, padn);
290 sha1_update (ctx, msglen, 8);
291
292 PUT_UINT32_BE (ctx->state[0], output, 0);
293 PUT_UINT32_BE (ctx->state[1], output, 4);
294 PUT_UINT32_BE (ctx->state[2], output, 8);
295 PUT_UINT32_BE (ctx->state[3], output, 12);
296 PUT_UINT32_BE (ctx->state[4], output, 16);
297 }
298
299 /*
300 * Output = SHA-1( input buffer )
301 */
302 void sha1_csum (unsigned char *input, int ilen, unsigned char output[20])
303 {
304 sha1_context ctx;
305
306 sha1_starts (&ctx);
307 sha1_update (&ctx, input, ilen);
308 sha1_finish (&ctx, output);
309 }
310
311 /*
312 * Output = HMAC-SHA-1( input buffer, hmac key )
313 */
314 void sha1_hmac (unsigned char *key, int keylen,
315 unsigned char *input, int ilen, unsigned char output[20])
316 {
317 int i;
318 sha1_context ctx;
319 unsigned char k_ipad[64];
320 unsigned char k_opad[64];
321 unsigned char tmpbuf[20];
322
323 memset (k_ipad, 0x36, 64);
324 memset (k_opad, 0x5C, 64);
325
326 for (i = 0; i < keylen; i++) {
327 if (i >= 64)
328 break;
329
330 k_ipad[i] ^= key[i];
331 k_opad[i] ^= key[i];
332 }
333
334 sha1_starts (&ctx);
335 sha1_update (&ctx, k_ipad, 64);
336 sha1_update (&ctx, input, ilen);
337 sha1_finish (&ctx, tmpbuf);
338
339 sha1_starts (&ctx);
340 sha1_update (&ctx, k_opad, 64);
341 sha1_update (&ctx, tmpbuf, 20);
342 sha1_finish (&ctx, output);
343
344 memset (k_ipad, 0, 64);
345 memset (k_opad, 0, 64);
346 memset (tmpbuf, 0, 20);
347 memset (&ctx, 0, sizeof (sha1_context));
348 }
349
350 static const char _sha1_src[] = "_sha1_src";
351
352 #ifdef SELF_TEST
353 /*
354 * FIPS-180-1 test vectors
355 */
356 static const char sha1_test_str[3][57] = {
357 {"abc"},
358 {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
359 {""}
360 };
361
362 static const unsigned char sha1_test_sum[3][20] = {
363 {0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
364 0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D},
365 {0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
366 0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1},
367 {0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
368 0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F}
369 };
370
371 /*
372 * Checkup routine
373 */
374 int sha1_self_test (void)
375 {
376 int i, j;
377 unsigned char buf[1000];
378 unsigned char sha1sum[20];
379 sha1_context ctx;
380
381 for (i = 0; i < 3; i++) {
382 printf (" SHA-1 test #%d: ", i + 1);
383
384 sha1_starts (&ctx);
385
386 if (i < 2)
387 sha1_update (&ctx, (unsigned char *) sha1_test_str[i],
388 strlen (sha1_test_str[i]));
389 else {
390 memset (buf, 'a', 1000);
391 for (j = 0; j < 1000; j++)
392 sha1_update (&ctx, buf, 1000);
393 }
394
395 sha1_finish (&ctx, sha1sum);
396
397 if (memcmp (sha1sum, sha1_test_sum[i], 20) != 0) {
398 printf ("failed\n");
399 return (1);
400 }
401
402 printf ("passed\n");
403 }
404
405 printf ("\n");
406 return (0);
407 }
408 #else
409 int sha1_self_test (void)
410 {
411 return (0);
412 }
413 #endif
Fork of the u-boot for for Samsung based MINI2440 board