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