| /* | |
| SHA-1 in C | |
| By Steve Reid <sreid@sea-to-sky.net> | |
| 100% Public Domain | |
| ----------------- | |
| Modified 7/98 | |
| By James H. Brown <jbrown@burgoyne.com> | |
| Still 100% Public Domain | |
| Corrected a problem which generated improper hash values on 16 bit machines | |
| Routine SHA1Update changed from | |
| void SHA1Update(SHA_CTX* context, unsigned char* data, unsigned int | |
| len) | |
| to | |
| void SHA1Update(SHA_CTX* context, unsigned char* data, unsigned | |
| long len) | |
| The 'len' parameter was declared an int which works fine on 32 bit machines. | |
| However, on 16 bit machines an int is too small for the shifts being done | |
| against | |
| it. This caused the hash function to generate incorrect values if len was | |
| greater than 8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update(). | |
| Since the file IO in main() reads 16K at a time, any file 8K or larger would | |
| be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million | |
| "a"s). | |
| I also changed the declaration of variables i & j in SHA1Update to | |
| unsigned long from unsigned int for the same reason. | |
| These changes should make no difference to any 32 bit implementations since | |
| an | |
| int and a long are the same size in those environments. | |
| -- | |
| I also corrected a few compiler warnings generated by Borland C. | |
| 1. Added #include <process.h> for exit() prototype | |
| 2. Removed unused variable 'j' in SHA1Final | |
| 3. Changed exit(0) to return(0) at end of main. | |
| ALL changes I made can be located by searching for comments containing 'JHB' | |
| ----------------- | |
| Modified 8/98 | |
| By Steve Reid <sreid@sea-to-sky.net> | |
| Still 100% public domain | |
| 1- Removed #include <process.h> and used return() instead of exit() | |
| 2- Fixed overwriting of finalcount in SHA1Final() (discovered by Chris Hall) | |
| 3- Changed email address from steve@edmweb.com to sreid@sea-to-sky.net | |
| ----------------- | |
| Modified 4/01 | |
| By Saul Kravitz <Saul.Kravitz@celera.com> | |
| Still 100% PD | |
| Modified to run on Compaq Alpha hardware. | |
| ----------------- | |
| Modified 07/2002 | |
| By Ralph Giles <giles@ghostscript.com> | |
| Still 100% public domain | |
| modified for use with stdint types, autoconf | |
| code cleanup, removed attribution comments | |
| switched SHA1Final() argument order for consistency | |
| use SHA1_ prefix for public api | |
| move public api to sha1.h | |
| */ | |
| /* | |
| 11/2016 adapted for CivetWeb: | |
| include sha1.h in sha1.c, | |
| rename to sha1.inl | |
| remove unused #ifdef sections | |
| make endian independent | |
| align buffer to 4 bytes | |
| remove unused variable assignments | |
| */ | |
| /* | |
| Test Vectors (from FIPS PUB 180-1) | |
| "abc" | |
| A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D | |
| "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" | |
| 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1 | |
| A million repetitions of "a" | |
| 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F | |
| */ | |
| #include <stdint.h> | |
| #include <string.h> | |
| typedef struct { | |
| uint32_t state[5]; | |
| uint32_t count[2]; | |
| uint8_t buffer[64]; | |
| } SHA_CTX; | |
| #define SHA1_DIGEST_SIZE 20 | |
| #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | |
| /* blk0() and blk() perform the initial expand. */ | |
| /* I got the idea of expanding during the round function from SSLeay */ | |
| typedef union { | |
| uint8_t c[64]; | |
| uint32_t l[16]; | |
| } CHAR64LONG16; | |
| static uint32_t | |
| blk0(CHAR64LONG16 *block, int i) | |
| { | |
| static const uint32_t n = 1u; | |
| if ((*((uint8_t *)(&n))) == 1) { | |
| /* little endian / intel byte order */ | |
| block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | |
| | (rol(block->l[i], 8) & 0x00FF00FF); | |
| } | |
| return block->l[i]; | |
| } | |
| #define blk(block, i) \ | |
| ((block)->l[(i)&15] = \ | |
| rol((block)->l[((i) + 13) & 15] ^ (block)->l[((i) + 8) & 15] \ | |
| ^ (block)->l[((i) + 2) & 15] ^ (block)->l[(i)&15], \ | |
| 1)) | |
| /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */ | |
| #define R0(v, w, x, y, z, i) \ | |
| z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5); \ | |
| w = rol(w, 30); | |
| #define R1(v, w, x, y, z, i) \ | |
| z += ((w & (x ^ y)) ^ y) + blk(block, i) + 0x5A827999 + rol(v, 5); \ | |
| w = rol(w, 30); | |
| #define R2(v, w, x, y, z, i) \ | |
| z += (w ^ x ^ y) + blk(block, i) + 0x6ED9EBA1 + rol(v, 5); \ | |
| w = rol(w, 30); | |
| #define R3(v, w, x, y, z, i) \ | |
| z += (((w | x) & y) | (w & x)) + blk(block, i) + 0x8F1BBCDC + rol(v, 5); \ | |
| w = rol(w, 30); | |
| #define R4(v, w, x, y, z, i) \ | |
| z += (w ^ x ^ y) + blk(block, i) + 0xCA62C1D6 + rol(v, 5); \ | |
| w = rol(w, 30); | |
| /* Hash a single 512-bit block. This is the core of the algorithm. */ | |
| static void | |
| SHA1_Transform(uint32_t state[5], const uint8_t buffer[64]) | |
| { | |
| uint32_t a, b, c, d, e; | |
| /* Must use an aligned, read/write buffer */ | |
| CHAR64LONG16 block[1]; | |
| memcpy(block, buffer, sizeof(block)); | |
| /* 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; | |
| } | |
| /* SHA1Init - Initialize new context */ | |
| SHA_API void | |
| SHA1_Init(SHA_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; | |
| } | |
| SHA_API void | |
| SHA1_Update(SHA_CTX *context, const uint8_t *data, const uint32_t len) | |
| { | |
| uint32_t i, 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) { | |
| i = 64 - j; | |
| memcpy(&context->buffer[j], data, i); | |
| SHA1_Transform(context->state, context->buffer); | |
| for (; i + 63 < len; i += 64) { | |
| SHA1_Transform(context->state, &data[i]); | |
| } | |
| j = 0; | |
| } else { | |
| i = 0; | |
| } | |
| memcpy(&context->buffer[j], &data[i], len - i); | |
| } | |
| /* Add padding and return the message digest. */ | |
| SHA_API void | |
| SHA1_Final(unsigned char *digest, SHA_CTX *context) | |
| { | |
| uint32_t i; | |
| uint8_t finalcount[8]; | |
| for (i = 0; i < 8; i++) { | |
| finalcount[i] = | |
| (uint8_t)((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) | |
| & 255); /* Endian independent */ | |
| } | |
| SHA1_Update(context, (uint8_t *)"\x80", 1); | |
| while ((context->count[0] & 504) != 448) { | |
| SHA1_Update(context, (uint8_t *)"\x00", 1); | |
| } | |
| SHA1_Update(context, finalcount, 8); /* Should cause a SHA1_Transform() */ | |
| for (i = 0; i < SHA1_DIGEST_SIZE; i++) { | |
| digest[i] = | |
| (uint8_t)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255); | |
| } | |
| /* Wipe variables */ | |
| memset(context, '\0', sizeof(*context)); | |
| } | |
| /* End of sha1.inl */ |