1 // SPDX-License-Identifier: LGPL-2.1 2 /* 3 * Heiko Schocher, DENX Software Engineering, hs (at) denx.de. 4 * based on: 5 * FIPS-180-1 compliant SHA-1 implementation 6 * 7 * Copyright (C) 2003-2006 Christophe Devine 8 */ 9 /* 10 * The SHA-1 standard was published by NIST in 1993. 11 * 12 * http://www.itl.nist.gov/fipspubs/fip180-1.htm 13 */ 14 15 #ifndef _CRT_SECURE_NO_DEPRECATE 16 #define _CRT_SECURE_NO_DEPRECATE 1 17 #endif 18 19 #ifndef USE_HOSTCC 20 #include <common.h> 21 #include <linux/string.h> 22 #else 23 #include <string.h> 24 #endif /* USE_HOSTCC */ 25 #include <watchdog.h> 26 #include <u-boot/sha1.h> 27 28 const uint8_t sha1_der_prefix[SHA1_DER_LEN] = { 29 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 30 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 31 }; 32 33 /* 34 * 32-bit integer manipulation macros (big endian) 35 */ 36 #ifndef GET_UINT32_BE 37 #define GET_UINT32_BE(n,b,i) { \ 38 (n) = ( (unsigned long) (b)[(i) ] << 24 ) \ 39 | ( (unsigned long) (b)[(i) + 1] << 16 ) \ 40 | ( (unsigned long) (b)[(i) + 2] << 8 ) \ 41 | ( (unsigned long) (b)[(i) + 3] ); \ 42 } 43 #endif 44 #ifndef PUT_UINT32_BE 45 #define PUT_UINT32_BE(n,b,i) { \ 46 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \ 47 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \ 48 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \ 49 (b)[(i) + 3] = (unsigned char) ( (n) ); \ 50 } 51 #endif 52 53 /* 54 * SHA-1 context setup 55 */ 56 void sha1_starts (sha1_context * ctx) 57 { 58 ctx->total[0] = 0; 59 ctx->total[1] = 0; 60 61 ctx->state[0] = 0x67452301; 62 ctx->state[1] = 0xEFCDAB89; 63 ctx->state[2] = 0x98BADCFE; 64 ctx->state[3] = 0x10325476; 65 ctx->state[4] = 0xC3D2E1F0; 66 } 67 68 static void sha1_process(sha1_context *ctx, const unsigned char data[64]) 69 { 70 unsigned long temp, W[16], A, B, C, D, E; 71 72 GET_UINT32_BE (W[0], data, 0); 73 GET_UINT32_BE (W[1], data, 4); 74 GET_UINT32_BE (W[2], data, 8); 75 GET_UINT32_BE (W[3], data, 12); 76 GET_UINT32_BE (W[4], data, 16); 77 GET_UINT32_BE (W[5], data, 20); 78 GET_UINT32_BE (W[6], data, 24); 79 GET_UINT32_BE (W[7], data, 28); 80 GET_UINT32_BE (W[8], data, 32); 81 GET_UINT32_BE (W[9], data, 36); 82 GET_UINT32_BE (W[10], data, 40); 83 GET_UINT32_BE (W[11], data, 44); 84 GET_UINT32_BE (W[12], data, 48); 85 GET_UINT32_BE (W[13], data, 52); 86 GET_UINT32_BE (W[14], data, 56); 87 GET_UINT32_BE (W[15], data, 60); 88 89 #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n))) 90 91 #define R(t) ( \ 92 temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ \ 93 W[(t - 14) & 0x0F] ^ W[ t & 0x0F], \ 94 ( W[t & 0x0F] = S(temp,1) ) \ 95 ) 96 97 #define P(a,b,c,d,e,x) { \ 98 e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \ 99 } 100 101 A = ctx->state[0]; 102 B = ctx->state[1]; 103 C = ctx->state[2]; 104 D = ctx->state[3]; 105 E = ctx->state[4]; 106 107 #define F(x,y,z) (z ^ (x & (y ^ z))) 108 #define K 0x5A827999 109 110 P (A, B, C, D, E, W[0]); 111 P (E, A, B, C, D, W[1]); 112 P (D, E, A, B, C, W[2]); 113 P (C, D, E, A, B, W[3]); 114 P (B, C, D, E, A, W[4]); 115 P (A, B, C, D, E, W[5]); 116 P (E, A, B, C, D, W[6]); 117 P (D, E, A, B, C, W[7]); 118 P (C, D, E, A, B, W[8]); 119 P (B, C, D, E, A, W[9]); 120 P (A, B, C, D, E, W[10]); 121 P (E, A, B, C, D, W[11]); 122 P (D, E, A, B, C, W[12]); 123 P (C, D, E, A, B, W[13]); 124 P (B, C, D, E, A, W[14]); 125 P (A, B, C, D, E, W[15]); 126 P (E, A, B, C, D, R (16)); 127 P (D, E, A, B, C, R (17)); 128 P (C, D, E, A, B, R (18)); 129 P (B, C, D, E, A, R (19)); 130 131 #undef K 132 #undef F 133 134 #define F(x,y,z) (x ^ y ^ z) 135 #define K 0x6ED9EBA1 136 137 P (A, B, C, D, E, R (20)); 138 P (E, A, B, C, D, R (21)); 139 P (D, E, A, B, C, R (22)); 140 P (C, D, E, A, B, R (23)); 141 P (B, C, D, E, A, R (24)); 142 P (A, B, C, D, E, R (25)); 143 P (E, A, B, C, D, R (26)); 144 P (D, E, A, B, C, R (27)); 145 P (C, D, E, A, B, R (28)); 146 P (B, C, D, E, A, R (29)); 147 P (A, B, C, D, E, R (30)); 148 P (E, A, B, C, D, R (31)); 149 P (D, E, A, B, C, R (32)); 150 P (C, D, E, A, B, R (33)); 151 P (B, C, D, E, A, R (34)); 152 P (A, B, C, D, E, R (35)); 153 P (E, A, B, C, D, R (36)); 154 P (D, E, A, B, C, R (37)); 155 P (C, D, E, A, B, R (38)); 156 P (B, C, D, E, A, R (39)); 157 158 #undef K 159 #undef F 160 161 #define F(x,y,z) ((x & y) | (z & (x | y))) 162 #define K 0x8F1BBCDC 163 164 P (A, B, C, D, E, R (40)); 165 P (E, A, B, C, D, R (41)); 166 P (D, E, A, B, C, R (42)); 167 P (C, D, E, A, B, R (43)); 168 P (B, C, D, E, A, R (44)); 169 P (A, B, C, D, E, R (45)); 170 P (E, A, B, C, D, R (46)); 171 P (D, E, A, B, C, R (47)); 172 P (C, D, E, A, B, R (48)); 173 P (B, C, D, E, A, R (49)); 174 P (A, B, C, D, E, R (50)); 175 P (E, A, B, C, D, R (51)); 176 P (D, E, A, B, C, R (52)); 177 P (C, D, E, A, B, R (53)); 178 P (B, C, D, E, A, R (54)); 179 P (A, B, C, D, E, R (55)); 180 P (E, A, B, C, D, R (56)); 181 P (D, E, A, B, C, R (57)); 182 P (C, D, E, A, B, R (58)); 183 P (B, C, D, E, A, R (59)); 184 185 #undef K 186 #undef F 187 188 #define F(x,y,z) (x ^ y ^ z) 189 #define K 0xCA62C1D6 190 191 P (A, B, C, D, E, R (60)); 192 P (E, A, B, C, D, R (61)); 193 P (D, E, A, B, C, R (62)); 194 P (C, D, E, A, B, R (63)); 195 P (B, C, D, E, A, R (64)); 196 P (A, B, C, D, E, R (65)); 197 P (E, A, B, C, D, R (66)); 198 P (D, E, A, B, C, R (67)); 199 P (C, D, E, A, B, R (68)); 200 P (B, C, D, E, A, R (69)); 201 P (A, B, C, D, E, R (70)); 202 P (E, A, B, C, D, R (71)); 203 P (D, E, A, B, C, R (72)); 204 P (C, D, E, A, B, R (73)); 205 P (B, C, D, E, A, R (74)); 206 P (A, B, C, D, E, R (75)); 207 P (E, A, B, C, D, R (76)); 208 P (D, E, A, B, C, R (77)); 209 P (C, D, E, A, B, R (78)); 210 P (B, C, D, E, A, R (79)); 211 212 #undef K 213 #undef F 214 215 ctx->state[0] += A; 216 ctx->state[1] += B; 217 ctx->state[2] += C; 218 ctx->state[3] += D; 219 ctx->state[4] += E; 220 } 221 222 /* 223 * SHA-1 process buffer 224 */ 225 void sha1_update(sha1_context *ctx, const unsigned char *input, 226 unsigned int ilen) 227 { 228 int fill; 229 unsigned long left; 230 231 if (ilen <= 0) 232 return; 233 234 left = ctx->total[0] & 0x3F; 235 fill = 64 - left; 236 237 ctx->total[0] += ilen; 238 ctx->total[0] &= 0xFFFFFFFF; 239 240 if (ctx->total[0] < (unsigned long) ilen) 241 ctx->total[1]++; 242 243 if (left && ilen >= fill) { 244 memcpy ((void *) (ctx->buffer + left), (void *) input, fill); 245 sha1_process (ctx, ctx->buffer); 246 input += fill; 247 ilen -= fill; 248 left = 0; 249 } 250 251 while (ilen >= 64) { 252 sha1_process (ctx, input); 253 input += 64; 254 ilen -= 64; 255 } 256 257 if (ilen > 0) { 258 memcpy ((void *) (ctx->buffer + left), (void *) input, ilen); 259 } 260 } 261 262 static const unsigned char sha1_padding[64] = { 263 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 264 0, 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 }; 268 269 /* 270 * SHA-1 final digest 271 */ 272 void sha1_finish (sha1_context * ctx, unsigned char output[20]) 273 { 274 unsigned long last, padn; 275 unsigned long high, low; 276 unsigned char msglen[8]; 277 278 high = (ctx->total[0] >> 29) 279 | (ctx->total[1] << 3); 280 low = (ctx->total[0] << 3); 281 282 PUT_UINT32_BE (high, msglen, 0); 283 PUT_UINT32_BE (low, msglen, 4); 284 285 last = ctx->total[0] & 0x3F; 286 padn = (last < 56) ? (56 - last) : (120 - last); 287 288 sha1_update (ctx, (unsigned char *) sha1_padding, padn); 289 sha1_update (ctx, msglen, 8); 290 291 PUT_UINT32_BE (ctx->state[0], output, 0); 292 PUT_UINT32_BE (ctx->state[1], output, 4); 293 PUT_UINT32_BE (ctx->state[2], output, 8); 294 PUT_UINT32_BE (ctx->state[3], output, 12); 295 PUT_UINT32_BE (ctx->state[4], output, 16); 296 } 297 298 /* 299 * Output = SHA-1( input buffer ) 300 */ 301 void sha1_csum(const unsigned char *input, unsigned int ilen, 302 unsigned char *output) 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 = SHA-1( input buffer ). Trigger the watchdog every 'chunk_sz' 313 * bytes of input processed. 314 */ 315 void sha1_csum_wd(const unsigned char *input, unsigned int ilen, 316 unsigned char *output, unsigned int chunk_sz) 317 { 318 sha1_context ctx; 319 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG) 320 const unsigned char *end, *curr; 321 int chunk; 322 #endif 323 324 sha1_starts (&ctx); 325 326 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG) 327 curr = input; 328 end = input + ilen; 329 while (curr < end) { 330 chunk = end - curr; 331 if (chunk > chunk_sz) 332 chunk = chunk_sz; 333 sha1_update (&ctx, curr, chunk); 334 curr += chunk; 335 WATCHDOG_RESET (); 336 } 337 #else 338 sha1_update (&ctx, input, ilen); 339 #endif 340 341 sha1_finish (&ctx, output); 342 } 343 344 /* 345 * Output = HMAC-SHA-1( input buffer, hmac key ) 346 */ 347 void sha1_hmac(const unsigned char *key, int keylen, 348 const unsigned char *input, unsigned int ilen, 349 unsigned char *output) 350 { 351 int i; 352 sha1_context ctx; 353 unsigned char k_ipad[64]; 354 unsigned char k_opad[64]; 355 unsigned char tmpbuf[20]; 356 357 memset (k_ipad, 0x36, 64); 358 memset (k_opad, 0x5C, 64); 359 360 for (i = 0; i < keylen; i++) { 361 if (i >= 64) 362 break; 363 364 k_ipad[i] ^= key[i]; 365 k_opad[i] ^= key[i]; 366 } 367 368 sha1_starts (&ctx); 369 sha1_update (&ctx, k_ipad, 64); 370 sha1_update (&ctx, input, ilen); 371 sha1_finish (&ctx, tmpbuf); 372 373 sha1_starts (&ctx); 374 sha1_update (&ctx, k_opad, 64); 375 sha1_update (&ctx, tmpbuf, 20); 376 sha1_finish (&ctx, output); 377 378 memset (k_ipad, 0, 64); 379 memset (k_opad, 0, 64); 380 memset (tmpbuf, 0, 20); 381 memset (&ctx, 0, sizeof (sha1_context)); 382 } 383 384 #ifdef SELF_TEST 385 /* 386 * FIPS-180-1 test vectors 387 */ 388 static const char sha1_test_str[3][57] = { 389 {"abc"}, 390 {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"}, 391 {""} 392 }; 393 394 static const unsigned char sha1_test_sum[3][20] = { 395 {0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E, 396 0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D}, 397 {0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE, 398 0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1}, 399 {0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E, 400 0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F} 401 }; 402 403 /* 404 * Checkup routine 405 */ 406 int sha1_self_test (void) 407 { 408 int i, j; 409 unsigned char buf[1000]; 410 unsigned char sha1sum[20]; 411 sha1_context ctx; 412 413 for (i = 0; i < 3; i++) { 414 printf (" SHA-1 test #%d: ", i + 1); 415 416 sha1_starts (&ctx); 417 418 if (i < 2) 419 sha1_update (&ctx, (unsigned char *) sha1_test_str[i], 420 strlen (sha1_test_str[i])); 421 else { 422 memset (buf, 'a', 1000); 423 for (j = 0; j < 1000; j++) 424 sha1_update (&ctx, buf, 1000); 425 } 426 427 sha1_finish (&ctx, sha1sum); 428 429 if (memcmp (sha1sum, sha1_test_sum[i], 20) != 0) { 430 printf ("failed\n"); 431 return (1); 432 } 433 434 printf ("passed\n"); 435 } 436 437 printf ("\n"); 438 return (0); 439 } 440 #else 441 int sha1_self_test (void) 442 { 443 return (0); 444 } 445 #endif 446
