lib/sha1.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   3  *  Heiko Schocher, DENX Software Engineering, hs@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