Merge git://www.denx.de/git/u-boot
[platform/kernel/u-boot.git] / lib_generic / sha1.c
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