blob: a121224855f4786f9ca92de5396bd1262301c6bc [file] [log] [blame]
Heiko Schocher566a4942007-06-22 19:11:54 +02001/*
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
Bartlomiej Sieka75903782008-04-25 13:54:02 +020032#ifndef USE_HOSTCC
33#include <common.h>
Andy Fleminga94f22f2008-06-11 18:10:20 -050034#include <linux/string.h>
Wolfgang Denk338cc032008-06-06 14:28:14 +020035#else
36#include <string.h>
Bartlomiej Sieka75903782008-04-25 13:54:02 +020037#endif /* USE_HOSTCC */
38#include <watchdog.h>
Heiko Schocher566a4942007-06-22 19:11:54 +020039#include "sha1.h"
40
41/*
42 * 32-bit integer manipulation macros (big endian)
43 */
44#ifndef GET_UINT32_BE
Wolfgang Denk4ef218f2007-07-10 00:01:28 +020045#define GET_UINT32_BE(n,b,i) { \
46 (n) = ( (unsigned long) (b)[(i) ] << 24 ) \
47 | ( (unsigned long) (b)[(i) + 1] << 16 ) \
48 | ( (unsigned long) (b)[(i) + 2] << 8 ) \
49 | ( (unsigned long) (b)[(i) + 3] ); \
Heiko Schocher566a4942007-06-22 19:11:54 +020050}
51#endif
52#ifndef PUT_UINT32_BE
Wolfgang Denk4ef218f2007-07-10 00:01:28 +020053#define PUT_UINT32_BE(n,b,i) { \
54 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
55 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
56 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
57 (b)[(i) + 3] = (unsigned char) ( (n) ); \
Heiko Schocher566a4942007-06-22 19:11:54 +020058}
59#endif
60
61/*
62 * SHA-1 context setup
63 */
Wolfgang Denk4ef218f2007-07-10 00:01:28 +020064void sha1_starts (sha1_context * ctx)
Heiko Schocher566a4942007-06-22 19:11:54 +020065{
Wolfgang Denk4ef218f2007-07-10 00:01:28 +020066 ctx->total[0] = 0;
67 ctx->total[1] = 0;
Heiko Schocher566a4942007-06-22 19:11:54 +020068
Wolfgang Denk4ef218f2007-07-10 00:01:28 +020069 ctx->state[0] = 0x67452301;
70 ctx->state[1] = 0xEFCDAB89;
71 ctx->state[2] = 0x98BADCFE;
72 ctx->state[3] = 0x10325476;
73 ctx->state[4] = 0xC3D2E1F0;
Heiko Schocher566a4942007-06-22 19:11:54 +020074}
75
Simon Glassa7d1d762012-12-05 14:46:33 +000076static void sha1_process(sha1_context *ctx, const unsigned char data[64])
Heiko Schocher566a4942007-06-22 19:11:54 +020077{
Wolfgang Denk4ef218f2007-07-10 00:01:28 +020078 unsigned long temp, W[16], A, B, C, D, E;
Heiko Schocher566a4942007-06-22 19:11:54 +020079
Wolfgang Denk4ef218f2007-07-10 00:01:28 +020080 GET_UINT32_BE (W[0], data, 0);
81 GET_UINT32_BE (W[1], data, 4);
82 GET_UINT32_BE (W[2], data, 8);
83 GET_UINT32_BE (W[3], data, 12);
84 GET_UINT32_BE (W[4], data, 16);
85 GET_UINT32_BE (W[5], data, 20);
86 GET_UINT32_BE (W[6], data, 24);
87 GET_UINT32_BE (W[7], data, 28);
88 GET_UINT32_BE (W[8], data, 32);
89 GET_UINT32_BE (W[9], data, 36);
90 GET_UINT32_BE (W[10], data, 40);
91 GET_UINT32_BE (W[11], data, 44);
92 GET_UINT32_BE (W[12], data, 48);
93 GET_UINT32_BE (W[13], data, 52);
94 GET_UINT32_BE (W[14], data, 56);
95 GET_UINT32_BE (W[15], data, 60);
Heiko Schocher566a4942007-06-22 19:11:54 +020096
Wolfgang Denk4ef218f2007-07-10 00:01:28 +020097#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
Heiko Schocher566a4942007-06-22 19:11:54 +020098
Wolfgang Denk4ef218f2007-07-10 00:01:28 +020099#define R(t) ( \
100 temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ \
101 W[(t - 14) & 0x0F] ^ W[ t & 0x0F], \
102 ( W[t & 0x0F] = S(temp,1) ) \
Heiko Schocher566a4942007-06-22 19:11:54 +0200103)
104
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200105#define P(a,b,c,d,e,x) { \
106 e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \
Heiko Schocher566a4942007-06-22 19:11:54 +0200107}
108
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200109 A = ctx->state[0];
110 B = ctx->state[1];
111 C = ctx->state[2];
112 D = ctx->state[3];
113 E = ctx->state[4];
Heiko Schocher566a4942007-06-22 19:11:54 +0200114
115#define F(x,y,z) (z ^ (x & (y ^ z)))
116#define K 0x5A827999
117
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200118 P (A, B, C, D, E, W[0]);
119 P (E, A, B, C, D, W[1]);
120 P (D, E, A, B, C, W[2]);
121 P (C, D, E, A, B, W[3]);
122 P (B, C, D, E, A, W[4]);
123 P (A, B, C, D, E, W[5]);
124 P (E, A, B, C, D, W[6]);
125 P (D, E, A, B, C, W[7]);
126 P (C, D, E, A, B, W[8]);
127 P (B, C, D, E, A, W[9]);
128 P (A, B, C, D, E, W[10]);
129 P (E, A, B, C, D, W[11]);
130 P (D, E, A, B, C, W[12]);
131 P (C, D, E, A, B, W[13]);
132 P (B, C, D, E, A, W[14]);
133 P (A, B, C, D, E, W[15]);
134 P (E, A, B, C, D, R (16));
135 P (D, E, A, B, C, R (17));
136 P (C, D, E, A, B, R (18));
137 P (B, C, D, E, A, R (19));
Heiko Schocher566a4942007-06-22 19:11:54 +0200138
139#undef K
140#undef F
141
142#define F(x,y,z) (x ^ y ^ z)
143#define K 0x6ED9EBA1
144
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200145 P (A, B, C, D, E, R (20));
146 P (E, A, B, C, D, R (21));
147 P (D, E, A, B, C, R (22));
148 P (C, D, E, A, B, R (23));
149 P (B, C, D, E, A, R (24));
150 P (A, B, C, D, E, R (25));
151 P (E, A, B, C, D, R (26));
152 P (D, E, A, B, C, R (27));
153 P (C, D, E, A, B, R (28));
154 P (B, C, D, E, A, R (29));
155 P (A, B, C, D, E, R (30));
156 P (E, A, B, C, D, R (31));
157 P (D, E, A, B, C, R (32));
158 P (C, D, E, A, B, R (33));
159 P (B, C, D, E, A, R (34));
160 P (A, B, C, D, E, R (35));
161 P (E, A, B, C, D, R (36));
162 P (D, E, A, B, C, R (37));
163 P (C, D, E, A, B, R (38));
164 P (B, C, D, E, A, R (39));
Heiko Schocher566a4942007-06-22 19:11:54 +0200165
166#undef K
167#undef F
168
169#define F(x,y,z) ((x & y) | (z & (x | y)))
170#define K 0x8F1BBCDC
171
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200172 P (A, B, C, D, E, R (40));
173 P (E, A, B, C, D, R (41));
174 P (D, E, A, B, C, R (42));
175 P (C, D, E, A, B, R (43));
176 P (B, C, D, E, A, R (44));
177 P (A, B, C, D, E, R (45));
178 P (E, A, B, C, D, R (46));
179 P (D, E, A, B, C, R (47));
180 P (C, D, E, A, B, R (48));
181 P (B, C, D, E, A, R (49));
182 P (A, B, C, D, E, R (50));
183 P (E, A, B, C, D, R (51));
184 P (D, E, A, B, C, R (52));
185 P (C, D, E, A, B, R (53));
186 P (B, C, D, E, A, R (54));
187 P (A, B, C, D, E, R (55));
188 P (E, A, B, C, D, R (56));
189 P (D, E, A, B, C, R (57));
190 P (C, D, E, A, B, R (58));
191 P (B, C, D, E, A, R (59));
Heiko Schocher566a4942007-06-22 19:11:54 +0200192
193#undef K
194#undef F
195
196#define F(x,y,z) (x ^ y ^ z)
197#define K 0xCA62C1D6
198
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200199 P (A, B, C, D, E, R (60));
200 P (E, A, B, C, D, R (61));
201 P (D, E, A, B, C, R (62));
202 P (C, D, E, A, B, R (63));
203 P (B, C, D, E, A, R (64));
204 P (A, B, C, D, E, R (65));
205 P (E, A, B, C, D, R (66));
206 P (D, E, A, B, C, R (67));
207 P (C, D, E, A, B, R (68));
208 P (B, C, D, E, A, R (69));
209 P (A, B, C, D, E, R (70));
210 P (E, A, B, C, D, R (71));
211 P (D, E, A, B, C, R (72));
212 P (C, D, E, A, B, R (73));
213 P (B, C, D, E, A, R (74));
214 P (A, B, C, D, E, R (75));
215 P (E, A, B, C, D, R (76));
216 P (D, E, A, B, C, R (77));
217 P (C, D, E, A, B, R (78));
218 P (B, C, D, E, A, R (79));
Heiko Schocher566a4942007-06-22 19:11:54 +0200219
220#undef K
221#undef F
222
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200223 ctx->state[0] += A;
224 ctx->state[1] += B;
225 ctx->state[2] += C;
226 ctx->state[3] += D;
227 ctx->state[4] += E;
Heiko Schocher566a4942007-06-22 19:11:54 +0200228}
229
230/*
231 * SHA-1 process buffer
232 */
Simon Glassa7d1d762012-12-05 14:46:33 +0000233void sha1_update(sha1_context *ctx, const unsigned char *input,
234 unsigned int ilen)
Heiko Schocher566a4942007-06-22 19:11:54 +0200235{
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200236 int fill;
237 unsigned long left;
Heiko Schocher566a4942007-06-22 19:11:54 +0200238
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200239 if (ilen <= 0)
240 return;
Heiko Schocher566a4942007-06-22 19:11:54 +0200241
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200242 left = ctx->total[0] & 0x3F;
243 fill = 64 - left;
Heiko Schocher566a4942007-06-22 19:11:54 +0200244
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200245 ctx->total[0] += ilen;
246 ctx->total[0] &= 0xFFFFFFFF;
Heiko Schocher566a4942007-06-22 19:11:54 +0200247
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200248 if (ctx->total[0] < (unsigned long) ilen)
249 ctx->total[1]++;
Heiko Schocher566a4942007-06-22 19:11:54 +0200250
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200251 if (left && ilen >= fill) {
252 memcpy ((void *) (ctx->buffer + left), (void *) input, fill);
253 sha1_process (ctx, ctx->buffer);
254 input += fill;
255 ilen -= fill;
256 left = 0;
257 }
Heiko Schocher566a4942007-06-22 19:11:54 +0200258
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200259 while (ilen >= 64) {
260 sha1_process (ctx, input);
261 input += 64;
262 ilen -= 64;
263 }
Heiko Schocher566a4942007-06-22 19:11:54 +0200264
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200265 if (ilen > 0) {
266 memcpy ((void *) (ctx->buffer + left), (void *) input, ilen);
267 }
Heiko Schocher566a4942007-06-22 19:11:54 +0200268}
269
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200270static const unsigned char sha1_padding[64] = {
271 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
272 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
273 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
274 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
Heiko Schocher566a4942007-06-22 19:11:54 +0200275};
276
277/*
278 * SHA-1 final digest
279 */
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200280void sha1_finish (sha1_context * ctx, unsigned char output[20])
Heiko Schocher566a4942007-06-22 19:11:54 +0200281{
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200282 unsigned long last, padn;
283 unsigned long high, low;
284 unsigned char msglen[8];
Heiko Schocher566a4942007-06-22 19:11:54 +0200285
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200286 high = (ctx->total[0] >> 29)
287 | (ctx->total[1] << 3);
288 low = (ctx->total[0] << 3);
Heiko Schocher566a4942007-06-22 19:11:54 +0200289
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200290 PUT_UINT32_BE (high, msglen, 0);
291 PUT_UINT32_BE (low, msglen, 4);
Heiko Schocher566a4942007-06-22 19:11:54 +0200292
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200293 last = ctx->total[0] & 0x3F;
294 padn = (last < 56) ? (56 - last) : (120 - last);
Heiko Schocher566a4942007-06-22 19:11:54 +0200295
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200296 sha1_update (ctx, (unsigned char *) sha1_padding, padn);
297 sha1_update (ctx, msglen, 8);
Heiko Schocher566a4942007-06-22 19:11:54 +0200298
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200299 PUT_UINT32_BE (ctx->state[0], output, 0);
300 PUT_UINT32_BE (ctx->state[1], output, 4);
301 PUT_UINT32_BE (ctx->state[2], output, 8);
302 PUT_UINT32_BE (ctx->state[3], output, 12);
303 PUT_UINT32_BE (ctx->state[4], output, 16);
Heiko Schocher566a4942007-06-22 19:11:54 +0200304}
305
306/*
307 * Output = SHA-1( input buffer )
308 */
Simon Glassa7d1d762012-12-05 14:46:33 +0000309void sha1_csum(const unsigned char *input, unsigned int ilen,
310 unsigned char *output)
Heiko Schocher566a4942007-06-22 19:11:54 +0200311{
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200312 sha1_context ctx;
Heiko Schocher566a4942007-06-22 19:11:54 +0200313
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200314 sha1_starts (&ctx);
315 sha1_update (&ctx, input, ilen);
316 sha1_finish (&ctx, output);
Heiko Schocher566a4942007-06-22 19:11:54 +0200317}
318
319/*
Bartlomiej Sieka215b01b2008-04-22 12:27:56 +0200320 * Output = SHA-1( input buffer ). Trigger the watchdog every 'chunk_sz'
321 * bytes of input processed.
322 */
Simon Glassa7d1d762012-12-05 14:46:33 +0000323void sha1_csum_wd(const unsigned char *input, unsigned int ilen,
324 unsigned char *output, unsigned int chunk_sz)
Bartlomiej Sieka215b01b2008-04-22 12:27:56 +0200325{
326 sha1_context ctx;
327#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
Simon Glassa7d1d762012-12-05 14:46:33 +0000328 const unsigned char *end, *curr;
Bartlomiej Sieka215b01b2008-04-22 12:27:56 +0200329 int chunk;
330#endif
331
332 sha1_starts (&ctx);
333
334#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
335 curr = input;
336 end = input + ilen;
337 while (curr < end) {
338 chunk = end - curr;
339 if (chunk > chunk_sz)
340 chunk = chunk_sz;
341 sha1_update (&ctx, curr, chunk);
342 curr += chunk;
343 WATCHDOG_RESET ();
344 }
345#else
346 sha1_update (&ctx, input, ilen);
347#endif
348
349 sha1_finish (&ctx, output);
350}
351
352/*
Heiko Schocher566a4942007-06-22 19:11:54 +0200353 * Output = HMAC-SHA-1( input buffer, hmac key )
354 */
Simon Glassa7d1d762012-12-05 14:46:33 +0000355void sha1_hmac(const unsigned char *key, int keylen,
356 const unsigned char *input, unsigned int ilen,
357 unsigned char *output)
Heiko Schocher566a4942007-06-22 19:11:54 +0200358{
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200359 int i;
360 sha1_context ctx;
361 unsigned char k_ipad[64];
362 unsigned char k_opad[64];
363 unsigned char tmpbuf[20];
Heiko Schocher566a4942007-06-22 19:11:54 +0200364
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200365 memset (k_ipad, 0x36, 64);
366 memset (k_opad, 0x5C, 64);
Heiko Schocher566a4942007-06-22 19:11:54 +0200367
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200368 for (i = 0; i < keylen; i++) {
369 if (i >= 64)
370 break;
Heiko Schocher566a4942007-06-22 19:11:54 +0200371
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200372 k_ipad[i] ^= key[i];
373 k_opad[i] ^= key[i];
374 }
Heiko Schocher566a4942007-06-22 19:11:54 +0200375
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200376 sha1_starts (&ctx);
377 sha1_update (&ctx, k_ipad, 64);
378 sha1_update (&ctx, input, ilen);
379 sha1_finish (&ctx, tmpbuf);
Heiko Schocher566a4942007-06-22 19:11:54 +0200380
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200381 sha1_starts (&ctx);
382 sha1_update (&ctx, k_opad, 64);
383 sha1_update (&ctx, tmpbuf, 20);
384 sha1_finish (&ctx, output);
Heiko Schocher566a4942007-06-22 19:11:54 +0200385
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200386 memset (k_ipad, 0, 64);
387 memset (k_opad, 0, 64);
388 memset (tmpbuf, 0, 20);
389 memset (&ctx, 0, sizeof (sha1_context));
Heiko Schocher566a4942007-06-22 19:11:54 +0200390}
391
392static const char _sha1_src[] = "_sha1_src";
393
394#ifdef SELF_TEST
395/*
396 * FIPS-180-1 test vectors
397 */
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200398static const char sha1_test_str[3][57] = {
399 {"abc"},
400 {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
401 {""}
Heiko Schocher566a4942007-06-22 19:11:54 +0200402};
403
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200404static const unsigned char sha1_test_sum[3][20] = {
405 {0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
406 0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D},
407 {0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
408 0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1},
409 {0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
410 0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F}
Heiko Schocher566a4942007-06-22 19:11:54 +0200411};
412
413/*
414 * Checkup routine
415 */
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200416int sha1_self_test (void)
Heiko Schocher566a4942007-06-22 19:11:54 +0200417{
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200418 int i, j;
419 unsigned char buf[1000];
420 unsigned char sha1sum[20];
421 sha1_context ctx;
Heiko Schocher566a4942007-06-22 19:11:54 +0200422
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200423 for (i = 0; i < 3; i++) {
424 printf (" SHA-1 test #%d: ", i + 1);
Heiko Schocher566a4942007-06-22 19:11:54 +0200425
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200426 sha1_starts (&ctx);
Heiko Schocher566a4942007-06-22 19:11:54 +0200427
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200428 if (i < 2)
429 sha1_update (&ctx, (unsigned char *) sha1_test_str[i],
430 strlen (sha1_test_str[i]));
431 else {
432 memset (buf, 'a', 1000);
433 for (j = 0; j < 1000; j++)
434 sha1_update (&ctx, buf, 1000);
435 }
Heiko Schocher566a4942007-06-22 19:11:54 +0200436
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200437 sha1_finish (&ctx, sha1sum);
Heiko Schocher566a4942007-06-22 19:11:54 +0200438
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200439 if (memcmp (sha1sum, sha1_test_sum[i], 20) != 0) {
440 printf ("failed\n");
441 return (1);
442 }
Heiko Schocher566a4942007-06-22 19:11:54 +0200443
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200444 printf ("passed\n");
445 }
Heiko Schocher566a4942007-06-22 19:11:54 +0200446
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200447 printf ("\n");
448 return (0);
Heiko Schocher566a4942007-06-22 19:11:54 +0200449}
450#else
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200451int sha1_self_test (void)
Heiko Schocher566a4942007-06-22 19:11:54 +0200452{
Wolfgang Denk4ef218f2007-07-10 00:01:28 +0200453 return (0);
Heiko Schocher566a4942007-06-22 19:11:54 +0200454}
455#endif