git.sur5r.net Git - u-boot/blob - 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  *  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, const 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, const unsigned char *input,
 234                  unsigned int ilen)
 235 {
 236         int fill;
 237         unsigned long left;
 238
 239         if (ilen <= 0)
 240                 return;
 241
 242         left = ctx->total[0] & 0x3F;
 243         fill = 64 - left;
 244
 245         ctx->total[0] += ilen;
 246         ctx->total[0] &= 0xFFFFFFFF;
 247
 248         if (ctx->total[0] < (unsigned long) ilen)
 249                 ctx->total[1]++;
 250
 251         if (left && ilen >= fill) {
 252                 memcpy ((void *) (ctx->buffer + left), (void *) input, fill);
 253                 sha1_process (ctx, ctx->buffer);
 254                 input += fill;
 255                 ilen -= fill;
 256                 left = 0;
 257         }
 258
 259         while (ilen >= 64) {
 260                 sha1_process (ctx, input);
 261                 input += 64;
 262                 ilen -= 64;
 263         }
 264
 265         if (ilen > 0) {
 266                 memcpy ((void *) (ctx->buffer + left), (void *) input, ilen);
 267         }
 268 }
 269
 270 static const unsigned char sha1_padding[64] = {
 271         0x80, 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            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 275 };
 276
 277 /*
 278  * SHA-1 final digest
 279  */
 280 void sha1_finish (sha1_context * ctx, unsigned char output[20])
 281 {
 282         unsigned long last, padn;
 283         unsigned long high, low;
 284         unsigned char msglen[8];
 285
 286         high = (ctx->total[0] >> 29)
 287                 | (ctx->total[1] << 3);
 288         low = (ctx->total[0] << 3);
 289
 290         PUT_UINT32_BE (high, msglen, 0);
 291         PUT_UINT32_BE (low, msglen, 4);
 292
 293         last = ctx->total[0] & 0x3F;
 294         padn = (last < 56) ? (56 - last) : (120 - last);
 295
 296         sha1_update (ctx, (unsigned char *) sha1_padding, padn);
 297         sha1_update (ctx, msglen, 8);
 298
 299         PUT_UINT32_BE (ctx->state[0], output, 0);
 300         PUT_UINT32_BE (ctx->state[1], output, 4);
 301         PUT_UINT32_BE (ctx->state[2], output, 8);
 302         PUT_UINT32_BE (ctx->state[3], output, 12);
 303         PUT_UINT32_BE (ctx->state[4], output, 16);
 304 }
 305
 306 /*
 307  * Output = SHA-1( input buffer )
 308  */
 309 void sha1_csum(const unsigned char *input, unsigned int ilen,
 310                unsigned char *output)
 311 {
 312         sha1_context ctx;
 313
 314         sha1_starts (&ctx);
 315         sha1_update (&ctx, input, ilen);
 316         sha1_finish (&ctx, output);
 317 }
 318
 319 /*
 320  * Output = SHA-1( input buffer ). Trigger the watchdog every 'chunk_sz'
 321  * bytes of input processed.
 322  */
 323 void sha1_csum_wd(const unsigned char *input, unsigned int ilen,
 324                   unsigned char *output, unsigned int chunk_sz)
 325 {
 326         sha1_context ctx;
 327 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
 328         const unsigned char *end, *curr;
 329         int chunk;
 330 #endif
 331
 332         sha1_starts (&ctx);
 333
 334 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
 335         curr = input;
 336         end = input + ilen;
 337         while (curr < end) {
 338                 chunk = end - curr;
 339                 if (chunk > chunk_sz)
 340                         chunk = chunk_sz;
 341                 sha1_update (&ctx, curr, chunk);
 342                 curr += chunk;
 343                 WATCHDOG_RESET ();
 344         }
 345 #else
 346         sha1_update (&ctx, input, ilen);
 347 #endif
 348
 349         sha1_finish (&ctx, output);
 350 }
 351
 352 /*
 353  * Output = HMAC-SHA-1( input buffer, hmac key )
 354  */
 355 void sha1_hmac(const unsigned char *key, int keylen,
 356                const unsigned char *input, unsigned int ilen,
 357                unsigned char *output)
 358 {
 359         int i;
 360         sha1_context ctx;
 361         unsigned char k_ipad[64];
 362         unsigned char k_opad[64];
 363         unsigned char tmpbuf[20];
 364
 365         memset (k_ipad, 0x36, 64);
 366         memset (k_opad, 0x5C, 64);
 367
 368         for (i = 0; i < keylen; i++) {
 369                 if (i >= 64)
 370                         break;
 371
 372                 k_ipad[i] ^= key[i];
 373                 k_opad[i] ^= key[i];
 374         }
 375
 376         sha1_starts (&ctx);
 377         sha1_update (&ctx, k_ipad, 64);
 378         sha1_update (&ctx, input, ilen);
 379         sha1_finish (&ctx, tmpbuf);
 380
 381         sha1_starts (&ctx);
 382         sha1_update (&ctx, k_opad, 64);
 383         sha1_update (&ctx, tmpbuf, 20);
 384         sha1_finish (&ctx, output);
 385
 386         memset (k_ipad, 0, 64);
 387         memset (k_opad, 0, 64);
 388         memset (tmpbuf, 0, 20);
 389         memset (&ctx, 0, sizeof (sha1_context));
 390 }
 391
 392 static const char _sha1_src[] = "_sha1_src";
 393
 394 #ifdef SELF_TEST
 395 /*
 396  * FIPS-180-1 test vectors
 397  */
 398 static const char sha1_test_str[3][57] = {
 399         {"abc"},
 400         {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
 401         {""}
 402 };
 403
 404 static const unsigned char sha1_test_sum[3][20] = {
 405         {0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
 406          0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D},
 407         {0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
 408          0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1},
 409         {0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
 410          0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F}
 411 };
 412
 413 /*
 414  * Checkup routine
 415  */
 416 int sha1_self_test (void)
 417 {
 418         int i, j;
 419         unsigned char buf[1000];
 420         unsigned char sha1sum[20];
 421         sha1_context ctx;
 422
 423         for (i = 0; i < 3; i++) {
 424                 printf ("  SHA-1 test #%d: ", i + 1);
 425
 426                 sha1_starts (&ctx);
 427
 428                 if (i < 2)
 429                         sha1_update (&ctx, (unsigned char *) sha1_test_str[i],
 430                                      strlen (sha1_test_str[i]));
 431                 else {
 432                         memset (buf, 'a', 1000);
 433                         for (j = 0; j < 1000; j++)
 434                                 sha1_update (&ctx, buf, 1000);
 435                 }
 436
 437                 sha1_finish (&ctx, sha1sum);
 438
 439                 if (memcmp (sha1sum, sha1_test_sum[i], 20) != 0) {
 440                         printf ("failed\n");
 441                         return (1);
 442                 }
 443
 444                 printf ("passed\n");
 445         }
 446
 447         printf ("\n");
 448         return (0);
 449 }
 450 #else
 451 int sha1_self_test (void)
 452 {
 453         return (0);
 454 }
 455 #endif