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