From d9757786bb5a2d7a6cc9bce7cfb1a8b52d6391cf Mon Sep 17 00:00:00 2001 From: jhurst Date: Wed, 15 Jul 2020 13:11:05 -0700 Subject: Moving sha1 into the library to reduce openssl dependency --- src/KM_sha1.cpp | 251 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 251 insertions(+) create mode 100644 src/KM_sha1.cpp (limited to 'src/KM_sha1.cpp') diff --git a/src/KM_sha1.cpp b/src/KM_sha1.cpp new file mode 100644 index 0000000..33d61ea --- /dev/null +++ b/src/KM_sha1.cpp @@ -0,0 +1,251 @@ +/* +SHA-1 in C +By Steve Reid +100% Public Domain + +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 + +using namespace Kumu; + +#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 */ +#ifndef KM_BIG_ENDIAN +#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \ + |(rol(block->l[i],8)&0x00FF00FF)) +#else +#define blk0(i) block->l[i] +#endif +#define blk(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(i)+0x5A827999+rol(v,5);w=rol(w,30); +#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30); +#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30); +#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30); +#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30); + + +/* Hash a single 512-bit block. This is the core of the algorithm. */ + +static void +SHA1Transform( + uint32_t state[5], + const unsigned char buffer[64]) +{ + typedef union + { + unsigned char c[64]; + uint32_t l[16]; + uint64_t q[8]; + } CHAR64LONG16; + + uint32_t a, b, c, d, e; + size_t i; + CHAR64LONG16 block[1]; /* use array to appear as a pointer */ + + block[0].q[0] = reinterpret_cast(buffer)->q[0]; + block[0].q[1] = reinterpret_cast(buffer)->q[1]; + block[0].q[2] = reinterpret_cast(buffer)->q[2]; + block[0].q[3] = reinterpret_cast(buffer)->q[3]; + block[0].q[4] = reinterpret_cast(buffer)->q[4]; + block[0].q[5] = reinterpret_cast(buffer)->q[5]; + block[0].q[6] = reinterpret_cast(buffer)->q[6]; + block[0].q[7] = reinterpret_cast(buffer)->q[7]; + + /* 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; + // memset(buffer, 0, 64); +} + + +/* SHA1Init - Initialize new context */ + +void +Kumu::SHA1_Init( + 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; +} + + +/* Run your data through this. */ + +void +Kumu::SHA1_Update( + SHA1_CTX * context, + const unsigned char *data, + 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) + { + 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; + } + else + { + i = 0; + } + + memcpy(&context->buffer[j], &data[i], len - i); +} + + +/* Add padding and return the message digest. */ + +void +Kumu::SHA1_Final( + unsigned char digest[20], + SHA1_CTX * context) +{ + 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; + SHA1_Update(context, &c, 1); + while ((context->count[0] & 504) != 448) + { + c = 0000; + SHA1_Update(context, &c, 1); + } + SHA1_Update(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); + } +} + +// +// KM_sha1.cpp +// -- cgit v1.2.3 From 046039d6cefb99790d52959d7a640fecbce4ab5c Mon Sep 17 00:00:00 2001 From: jhurst Date: Sun, 19 Jul 2020 11:35:27 -0700 Subject: editorial changes --- src/KM_sha1.cpp | 34 +++++++++++++++++----------------- src/KM_sha1.h | 9 +++++---- 2 files changed, 22 insertions(+), 21 deletions(-) (limited to 'src/KM_sha1.cpp') diff --git a/src/KM_sha1.cpp b/src/KM_sha1.cpp index 33d61ea..ae62b55 100644 --- a/src/KM_sha1.cpp +++ b/src/KM_sha1.cpp @@ -1,6 +1,6 @@ /* SHA-1 in C -By Steve Reid +By Steve Reid 100% Public Domain Test Vectors (from FIPS PUB 180-1) @@ -13,6 +13,7 @@ A million repetitions of "a" */ #include +#include using namespace Kumu; @@ -41,17 +42,17 @@ using namespace Kumu; static void SHA1Transform( - uint32_t state[5], - const unsigned char buffer[64]) + ui32_t state[5], + const byte_t buffer[64]) { typedef union { - unsigned char c[64]; - uint32_t l[16]; - uint64_t q[8]; + byte_t c[64]; + ui32_t l[16]; + ui64_t q[8]; } CHAR64LONG16; - uint32_t a, b, c, d, e; + ui32_t a, b, c, d, e; size_t i; CHAR64LONG16 block[1]; /* use array to appear as a pointer */ @@ -185,11 +186,11 @@ Kumu::SHA1_Init( void Kumu::SHA1_Update( SHA1_CTX * context, - const unsigned char *data, - uint32_t len + const byte_t *data, + ui32_t len ) { - uint32_t i, j; + ui32_t i, j; j = context->count[0]; if ((context->count[0] += len << 3) < j) @@ -219,16 +220,16 @@ Kumu::SHA1_Update( void Kumu::SHA1_Final( - unsigned char digest[20], + byte_t digest[20], SHA1_CTX * context) { - unsigned i; - unsigned char finalcount[8]; - unsigned char c; + size_t i; + byte_t finalcount[8]; + byte_t c; for (i = 0; i < 8; i++) { - finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */ + finalcount[i] = (byte_t) ((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */ } c = 0200; @@ -241,8 +242,7 @@ Kumu::SHA1_Final( SHA1_Update(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); + digest[i] = (byte_t)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255); } } diff --git a/src/KM_sha1.h b/src/KM_sha1.h index b68341c..ea232e2 100644 --- a/src/KM_sha1.h +++ b/src/KM_sha1.h @@ -1,5 +1,5 @@ /* -Copyright (c) 2006-2020, John Hurst +Copyright (c) 2020, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -32,13 +32,14 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef _KM_SHA1_H_ #define _KM_SHA1_H_ -#include +#include namespace Kumu { + int const SHA1_DIGEST_LENGTH = 20; typedef struct { - uint32_t state[5]; - uint32_t count[2]; + ui32_t state[5]; + ui32_t count[2]; byte_t buffer[64]; } SHA1_CTX; -- cgit v1.2.3 From c162e0da8e9b31ecd35ada7e5801ec6f4be45be6 Mon Sep 17 00:00:00 2001 From: jhurst Date: Sun, 19 Jul 2020 11:41:09 -0700 Subject: editorial change --- src/KM_sha1.cpp | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src/KM_sha1.cpp') diff --git a/src/KM_sha1.cpp b/src/KM_sha1.cpp index ae62b55..2b7fdb9 100644 --- a/src/KM_sha1.cpp +++ b/src/KM_sha1.cpp @@ -1,4 +1,6 @@ /* +public domain code distributed with asdcplib + SHA-1 in C By Steve Reid 100% Public Domain -- cgit v1.2.3