lib_generic/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  *  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