Annotation of elwix/tools/uboot_mkimage/lib/sha1.c, revision 1.1
1.1 ! misho 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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sha1.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / uboot_mkimage / lib