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 #ifndef USE_HOSTCC 33 #include <common.h> 34 #include <linux/string.h> 35 #else 36 #include <string.h> 37 #endif /* USE_HOSTCC */ 38 #include <watchdog.h> 39 #include "sha1.h" 40 41 /* 42 * 32-bit integer manipulation macros (big endian) 43 */ 44 #ifndef GET_UINT32_BE 45 #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] ); \ 50 } 51 #endif 52 #ifndef PUT_UINT32_BE 53 #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) ); \ 58 } 59 #endif 60 61 /* 62 * SHA-1 context setup 63 */ 64 void sha1_starts (sha1_context * ctx) 65 { 66 ctx->total[0] = 0; 67 ctx->total[1] = 0; 68 69 ctx->state[0] = 0x67452301; 70 ctx->state[1] = 0xEFCDAB89; 71 ctx->state[2] = 0x98BADCFE; 72 ctx->state[3] = 0x10325476; 73 ctx->state[4] = 0xC3D2E1F0; 74 } 75 76 static void sha1_process (sha1_context * ctx, unsigned char data[64]) 77 { 78 unsigned long temp, W[16], A, B, C, D, E; 79 80 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); 96 97 #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n))) 98 99 #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) ) \ 103 ) 104 105 #define P(a,b,c,d,e,x) { \ 106 e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \ 107 } 108 109 A = ctx->state[0]; 110 B = ctx->state[1]; 111 C = ctx->state[2]; 112 D = ctx->state[3]; 113 E = ctx->state[4]; 114 115 #define F(x,y,z) (z ^ (x & (y ^ z))) 116 #define K 0x5A827999 117 118 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)); 138 139 #undef K 140 #undef F 141 142 #define F(x,y,z) (x ^ y ^ z) 143 #define K 0x6ED9EBA1 144 145 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)); 165 166 #undef K 167 #undef F 168 169 #define F(x,y,z) ((x & y) | (z & (x | y))) 170 #define K 0x8F1BBCDC 171 172 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)); 192 193 #undef K 194 #undef F 195 196 #define F(x,y,z) (x ^ y ^ z) 197 #define K 0xCA62C1D6 198 199 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)); 219 220 #undef K 221 #undef F 222 223 ctx->state[0] += A; 224 ctx->state[1] += B; 225 ctx->state[2] += C; 226 ctx->state[3] += D; 227 ctx->state[4] += E; 228 } 229 230 /* 231 * SHA-1 process buffer 232 */ 233 void sha1_update (sha1_context * ctx, unsigned char *input, int ilen) 234 { 235 int fill; 236 unsigned long left; 237 238 if (ilen <= 0) 239 return; 240 241 left = ctx->total[0] & 0x3F; 242 fill = 64 - left; 243 244 ctx->total[0] += ilen; 245 ctx->total[0] &= 0xFFFFFFFF; 246 247 if (ctx->total[0] < (unsigned long) ilen) 248 ctx->total[1]++; 249 250 if (left && ilen >= fill) { 251 memcpy ((void *) (ctx->buffer + left), (void *) input, fill); 252 sha1_process (ctx, ctx->buffer); 253 input += fill; 254 ilen -= fill; 255 left = 0; 256 } 257 258 while (ilen >= 64) { 259 sha1_process (ctx, input); 260 input += 64; 261 ilen -= 64; 262 } 263 264 if (ilen > 0) { 265 memcpy ((void *) (ctx->buffer + left), (void *) input, ilen); 266 } 267 } 268 269 static const unsigned char sha1_padding[64] = { 270 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 271 0, 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 }; 275 276 /* 277 * SHA-1 final digest 278 */ 279 void sha1_finish (sha1_context * ctx, unsigned char output[20]) 280 { 281 unsigned long last, padn; 282 unsigned long high, low; 283 unsigned char msglen[8]; 284 285 high = (ctx->total[0] >> 29) 286 | (ctx->total[1] << 3); 287 low = (ctx->total[0] << 3); 288 289 PUT_UINT32_BE (high, msglen, 0); 290 PUT_UINT32_BE (low, msglen, 4); 291 292 last = ctx->total[0] & 0x3F; 293 padn = (last < 56) ? (56 - last) : (120 - last); 294 295 sha1_update (ctx, (unsigned char *) sha1_padding, padn); 296 sha1_update (ctx, msglen, 8); 297 298 PUT_UINT32_BE (ctx->state[0], output, 0); 299 PUT_UINT32_BE (ctx->state[1], output, 4); 300 PUT_UINT32_BE (ctx->state[2], output, 8); 301 PUT_UINT32_BE (ctx->state[3], output, 12); 302 PUT_UINT32_BE (ctx->state[4], output, 16); 303 } 304 305 /* 306 * Output = SHA-1( input buffer ) 307 */ 308 void sha1_csum (unsigned char *input, int ilen, unsigned char output[20]) 309 { 310 sha1_context ctx; 311 312 sha1_starts (&ctx); 313 sha1_update (&ctx, input, ilen); 314 sha1_finish (&ctx, output); 315 } 316 317 /* 318 * Output = SHA-1( input buffer ). Trigger the watchdog every 'chunk_sz' 319 * bytes of input processed. 320 */ 321 void sha1_csum_wd (unsigned char *input, int ilen, unsigned char output[20], 322 unsigned int chunk_sz) 323 { 324 sha1_context ctx; 325 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG) 326 unsigned char *end, *curr; 327 int chunk; 328 #endif 329 330 sha1_starts (&ctx); 331 332 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG) 333 curr = input; 334 end = input + ilen; 335 while (curr < end) { 336 chunk = end - curr; 337 if (chunk > chunk_sz) 338 chunk = chunk_sz; 339 sha1_update (&ctx, curr, chunk); 340 curr += chunk; 341 WATCHDOG_RESET (); 342 } 343 #else 344 sha1_update (&ctx, input, ilen); 345 #endif 346 347 sha1_finish (&ctx, output); 348 } 349 350 /* 351 * Output = HMAC-SHA-1( input buffer, hmac key ) 352 */ 353 void sha1_hmac (unsigned char *key, int keylen, 354 unsigned char *input, int ilen, unsigned char output[20]) 355 { 356 int i; 357 sha1_context ctx; 358 unsigned char k_ipad[64]; 359 unsigned char k_opad[64]; 360 unsigned char tmpbuf[20]; 361 362 memset (k_ipad, 0x36, 64); 363 memset (k_opad, 0x5C, 64); 364 365 for (i = 0; i < keylen; i++) { 366 if (i >= 64) 367 break; 368 369 k_ipad[i] ^= key[i]; 370 k_opad[i] ^= key[i]; 371 } 372 373 sha1_starts (&ctx); 374 sha1_update (&ctx, k_ipad, 64); 375 sha1_update (&ctx, input, ilen); 376 sha1_finish (&ctx, tmpbuf); 377 378 sha1_starts (&ctx); 379 sha1_update (&ctx, k_opad, 64); 380 sha1_update (&ctx, tmpbuf, 20); 381 sha1_finish (&ctx, output); 382 383 memset (k_ipad, 0, 64); 384 memset (k_opad, 0, 64); 385 memset (tmpbuf, 0, 20); 386 memset (&ctx, 0, sizeof (sha1_context)); 387 } 388 389 static const char _sha1_src[] = "_sha1_src"; 390 391 #ifdef SELF_TEST 392 /* 393 * FIPS-180-1 test vectors 394 */ 395 static const char sha1_test_str[3][57] = { 396 {"abc"}, 397 {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"}, 398 {""} 399 }; 400 401 static const unsigned char sha1_test_sum[3][20] = { 402 {0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E, 403 0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D}, 404 {0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE, 405 0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1}, 406 {0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E, 407 0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F} 408 }; 409 410 /* 411 * Checkup routine 412 */ 413 int sha1_self_test (void) 414 { 415 int i, j; 416 unsigned char buf[1000]; 417 unsigned char sha1sum[20]; 418 sha1_context ctx; 419 420 for (i = 0; i < 3; i++) { 421 printf (" SHA-1 test #%d: ", i + 1); 422 423 sha1_starts (&ctx); 424 425 if (i < 2) 426 sha1_update (&ctx, (unsigned char *) sha1_test_str[i], 427 strlen (sha1_test_str[i])); 428 else { 429 memset (buf, 'a', 1000); 430 for (j = 0; j < 1000; j++) 431 sha1_update (&ctx, buf, 1000); 432 } 433 434 sha1_finish (&ctx, sha1sum); 435 436 if (memcmp (sha1sum, sha1_test_sum[i], 20) != 0) { 437 printf ("failed\n"); 438 return (1); 439 } 440 441 printf ("passed\n"); 442 } 443 444 printf ("\n"); 445 return (0); 446 } 447 #else 448 int sha1_self_test (void) 449 { 450 return (0); 451 } 452 #endif 453