X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=sha1.c;h=4a5bedb8adccc4c658e61591c5123256b9c6b4ad;hp=9196664907c4b84f5270df3dfacf8471ab5be1b7;hb=0ecf3d77dc355f4bea99910a9dfb6f5866c9f73a;hpb=6833ce8bdca2d64e14485118f2a4417b7e1cb1b1 diff --git a/sha1.c b/sha1.c index 9196664..4a5bedb 100644 --- a/sha1.c +++ b/sha1.c @@ -17,6 +17,10 @@ #define SHA1HANDSOFF +#if HAVE_CONFIG_H +# include "config.h" +#endif + #include #include "sha1.h" @@ -45,146 +49,191 @@ /* Hash a single 512-bit block. This is the core of the algorithm. */ -void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]) +void SHA1Transform (uint32_t state[5], const unsigned char buffer[64]) { -uint32_t a, b, c, d, e; -typedef union { + uint32_t a, b, c, d, e; + typedef union { unsigned char c[64]; uint32_t l[16]; -} CHAR64LONG16; + } CHAR64LONG16; + #ifdef SHA1HANDSOFF -CHAR64LONG16 block[1]; /* use array to appear as a pointer */ - memcpy(block, buffer, 64); + CHAR64LONG16 block[1]; /* use array to appear as a pointer */ + + memcpy (block, buffer, 64); #else - /* The following had better never be used because it causes the - * pointer-to-const buffer to be cast into a pointer to non-const. - * And the result is written through. I threw a "const" in, hoping - * this will cause a diagnostic. - */ -CHAR64LONG16* block = (const CHAR64LONG16*)buffer; + /* The following had better never be used because it causes the + * pointer-to-const buffer to be cast into a pointer to non-const. + * And the result is written through. I threw a "const" in, hoping + * this will cause a diagnostic. + */ + CHAR64LONG16 *block = (const CHAR64LONG16 *) buffer; #endif - /* Copy context->state[] to working vars */ - a = state[0]; - b = state[1]; - c = state[2]; - d = state[3]; - e = state[4]; - /* 4 rounds of 20 operations each. Loop unrolled. */ - R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3); - R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7); - R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11); - R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15); - R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); - R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23); - R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27); - R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31); - R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35); - R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39); - R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43); - R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47); - R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51); - R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55); - R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59); - R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63); - R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67); - R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71); - R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75); - R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79); - /* Add the working vars back into context.state[] */ - state[0] += a; - state[1] += b; - state[2] += c; - state[3] += d; - state[4] += e; - /* Wipe variables */ - a = b = c = d = e = 0; + /* Copy context->state[] to working vars */ + a = state[0]; + b = state[1]; + c = state[2]; + d = state[3]; + e = state[4]; + /* 4 rounds of 20 operations each. Loop unrolled. */ + R0 (a, b, c, d, e, 0); + R0 (e, a, b, c, d, 1); + R0 (d, e, a, b, c, 2); + R0 (c, d, e, a, b, 3); + R0 (b, c, d, e, a, 4); + R0 (a, b, c, d, e, 5); + R0 (e, a, b, c, d, 6); + R0 (d, e, a, b, c, 7); + R0 (c, d, e, a, b, 8); + R0 (b, c, d, e, a, 9); + R0 (a, b, c, d, e, 10); + R0 (e, a, b, c, d, 11); + R0 (d, e, a, b, c, 12); + R0 (c, d, e, a, b, 13); + R0 (b, c, d, e, a, 14); + R0 (a, b, c, d, e, 15); + R1 (e, a, b, c, d, 16); + R1 (d, e, a, b, c, 17); + R1 (c, d, e, a, b, 18); + R1 (b, c, d, e, a, 19); + R2 (a, b, c, d, e, 20); + R2 (e, a, b, c, d, 21); + R2 (d, e, a, b, c, 22); + R2 (c, d, e, a, b, 23); + R2 (b, c, d, e, a, 24); + R2 (a, b, c, d, e, 25); + R2 (e, a, b, c, d, 26); + R2 (d, e, a, b, c, 27); + R2 (c, d, e, a, b, 28); + R2 (b, c, d, e, a, 29); + R2 (a, b, c, d, e, 30); + R2 (e, a, b, c, d, 31); + R2 (d, e, a, b, c, 32); + R2 (c, d, e, a, b, 33); + R2 (b, c, d, e, a, 34); + R2 (a, b, c, d, e, 35); + R2 (e, a, b, c, d, 36); + R2 (d, e, a, b, c, 37); + R2 (c, d, e, a, b, 38); + R2 (b, c, d, e, a, 39); + R3 (a, b, c, d, e, 40); + R3 (e, a, b, c, d, 41); + R3 (d, e, a, b, c, 42); + R3 (c, d, e, a, b, 43); + R3 (b, c, d, e, a, 44); + R3 (a, b, c, d, e, 45); + R3 (e, a, b, c, d, 46); + R3 (d, e, a, b, c, 47); + R3 (c, d, e, a, b, 48); + R3 (b, c, d, e, a, 49); + R3 (a, b, c, d, e, 50); + R3 (e, a, b, c, d, 51); + R3 (d, e, a, b, c, 52); + R3 (c, d, e, a, b, 53); + R3 (b, c, d, e, a, 54); + R3 (a, b, c, d, e, 55); + R3 (e, a, b, c, d, 56); + R3 (d, e, a, b, c, 57); + R3 (c, d, e, a, b, 58); + R3 (b, c, d, e, a, 59); + R4 (a, b, c, d, e, 60); + R4 (e, a, b, c, d, 61); + R4 (d, e, a, b, c, 62); + R4 (c, d, e, a, b, 63); + R4 (b, c, d, e, a, 64); + R4 (a, b, c, d, e, 65); + R4 (e, a, b, c, d, 66); + R4 (d, e, a, b, c, 67); + R4 (c, d, e, a, b, 68); + R4 (b, c, d, e, a, 69); + R4 (a, b, c, d, e, 70); + R4 (e, a, b, c, d, 71); + R4 (d, e, a, b, c, 72); + R4 (c, d, e, a, b, 73); + R4 (b, c, d, e, a, 74); + R4 (a, b, c, d, e, 75); + R4 (e, a, b, c, d, 76); + R4 (d, e, a, b, c, 77); + R4 (c, d, e, a, b, 78); + R4 (b, c, d, e, a, 79); + /* Add the working vars back into context.state[] */ + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + /* Wipe variables */ + a = b = c = d = e = 0; #ifdef SHA1HANDSOFF - memset(block, '\0', sizeof(block)); + memset (block, '\0', sizeof (block)); #endif } /* SHA1Init - Initialize new context */ -void SHA1Init(SHA1_CTX* context) +void SHA1Init (SHA1_CTX * context) { - /* SHA1 initialization constants */ - context->state[0] = 0x67452301; - context->state[1] = 0xEFCDAB89; - context->state[2] = 0x98BADCFE; - context->state[3] = 0x10325476; - context->state[4] = 0xC3D2E1F0; - context->count[0] = context->count[1] = 0; + /* SHA1 initialization constants */ + context->state[0] = 0x67452301; + context->state[1] = 0xEFCDAB89; + context->state[2] = 0x98BADCFE; + context->state[3] = 0x10325476; + context->state[4] = 0xC3D2E1F0; + context->count[0] = context->count[1] = 0; } /* Run your data through this. */ -void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len) +void SHA1Update (SHA1_CTX * context, const unsigned char *data, uint32_t len) { -uint32_t i; -uint32_t j; - - j = context->count[0]; - if ((context->count[0] += len << 3) < j) - context->count[1]++; - context->count[1] += (len>>29); - j = (j >> 3) & 63; - if ((j + len) > 63) { - memcpy(&context->buffer[j], data, (i = 64-j)); - SHA1Transform(context->state, context->buffer); - for ( ; i + 63 < len; i += 64) { - SHA1Transform(context->state, &data[i]); - } - j = 0; + uint32_t i; + uint32_t j; + + j = context->count[0]; + if ((context->count[0] += len << 3) < j) + context->count[1]++; + context->count[1] += (len >> 29); + j = (j >> 3) & 63; + if ((j + len) > 63) { + memcpy (&context->buffer[j], data, (i = 64 - j)); + SHA1Transform (context->state, context->buffer); + for (; i + 63 < len; i += 64) { + SHA1Transform (context->state, &data[i]); } - else i = 0; - memcpy(&context->buffer[j], &data[i], len - i); + j = 0; + } + else + i = 0; + memcpy (&context->buffer[j], &data[i], len - i); } /* Add padding and return the message digest. */ -void SHA1Final(unsigned char digest[20], SHA1_CTX* context) +void SHA1Final (unsigned char digest[20], SHA1_CTX * context) { -unsigned i; -unsigned char finalcount[8]; -unsigned char c; - -#if 0 /* untested "improvement" by DHR */ - /* Convert context->count to a sequence of bytes - * in finalcount. Second element first, but - * big-endian order within element. - * But we do it all backwards. - */ - unsigned char *fcp = &finalcount[8]; - - for (i = 0; i < 2; i++) - { - uint32_t t = context->count[i]; - int j; - - for (j = 0; j < 4; t >>= 8, j++) - *--fcp = (unsigned char) t - } -#else - for (i = 0; i < 8; i++) { - finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] - >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */ - } -#endif - c = 0200; - SHA1Update(context, &c, 1); - while ((context->count[0] & 504) != 448) { - c = 0000; - SHA1Update(context, &c, 1); - } - SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */ - for (i = 0; i < 20; i++) { - digest[i] = (unsigned char) - ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255); - } - /* Wipe variables */ - memset(context, '\0', sizeof(*context)); - memset(&finalcount, '\0', sizeof(finalcount)); + unsigned i; + unsigned char finalcount[8]; + unsigned char c; + + for (i = 0; i < 8; i++) { + finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] + >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */ + } + c = 0200; + SHA1Update (context, &c, 1); + while ((context->count[0] & 504) != 448) { + c = 0000; + SHA1Update (context, &c, 1); + } + SHA1Update (context, finalcount, 8); /* Should cause a SHA1Transform() */ + for (i = 0; i < 20; i++) { + digest[i] = (unsigned char) + ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255); + } + /* Wipe variables */ + memset (context, '\0', sizeof (*context)); + memset (&finalcount, '\0', sizeof (finalcount)); }