summaryrefslogtreecommitdiff
path: root/libs/sha1
diff options
context:
space:
mode:
authorClifford Wolf <clifford@clifford.at>2014-08-01 19:01:10 +0200
committerClifford Wolf <clifford@clifford.at>2014-08-01 19:01:10 +0200
commitbd74ed7da467de11128c57c4c424febe4a7e2f39 (patch)
tree8c6f55776de2d385193c12a2cacfa2733be0b09d /libs/sha1
parent1e224506be6d824ea9ed1855fa46d039e5ffefd5 (diff)
Replaced sha1 implementation
Diffstat (limited to 'libs/sha1')
-rw-r--r--libs/sha1/sha1.cpp455
-rw-r--r--libs/sha1/sha1.h106
2 files changed, 327 insertions, 234 deletions
diff --git a/libs/sha1/sha1.cpp b/libs/sha1/sha1.cpp
index fb7bfed6..dc86b2ce 100644
--- a/libs/sha1/sha1.cpp
+++ b/libs/sha1/sha1.cpp
@@ -1,185 +1,270 @@
-/*
- Copyright (c) 2011, Micael Hildenborg
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
- * Neither the name of Micael Hildenborg nor the
- names of its contributors may be used to endorse or promote products
- derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY Micael Hildenborg ''AS IS'' AND ANY
- EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL Micael Hildenborg BE LIABLE FOR ANY
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- Contributors:
- Gustav
- Several members in the gamedev.se forum.
- Gregory Petrosyan
- */
-
-#include "sha1.h"
-
-namespace sha1
-{
- namespace // local
- {
- // Rotate an integer value to left.
- inline unsigned int rol(const unsigned int value,
- const unsigned int steps)
- {
- return ((value << steps) | (value >> (32 - steps)));
- }
-
- // Sets the first 16 integers in the buffert to zero.
- // Used for clearing the W buffert.
- inline void clearWBuffert(unsigned int* buffert)
- {
- for (int pos = 16; --pos >= 0;)
- {
- buffert[pos] = 0;
- }
- }
-
- void innerHash(unsigned int* result, unsigned int* w)
- {
- unsigned int a = result[0];
- unsigned int b = result[1];
- unsigned int c = result[2];
- unsigned int d = result[3];
- unsigned int e = result[4];
-
- int round = 0;
-
- #define sha1macro(func,val) \
- { \
- const unsigned int t = rol(a, 5) + (func) + e + val + w[round]; \
- e = d; \
- d = c; \
- c = rol(b, 30); \
- b = a; \
- a = t; \
- }
-
- while (round < 16)
- {
- sha1macro((b & c) | (~b & d), 0x5a827999)
- ++round;
- }
- while (round < 20)
- {
- w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
- sha1macro((b & c) | (~b & d), 0x5a827999)
- ++round;
- }
- while (round < 40)
- {
- w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
- sha1macro(b ^ c ^ d, 0x6ed9eba1)
- ++round;
- }
- while (round < 60)
- {
- w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
- sha1macro((b & c) | (b & d) | (c & d), 0x8f1bbcdc)
- ++round;
- }
- while (round < 80)
- {
- w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
- sha1macro(b ^ c ^ d, 0xca62c1d6)
- ++round;
- }
-
- #undef sha1macro
-
- result[0] += a;
- result[1] += b;
- result[2] += c;
- result[3] += d;
- result[4] += e;
- }
- } // namespace
-
- void calc(const void* src, const int bytelength, unsigned char* hash)
- {
- // Init the result array.
- unsigned int result[5] = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 };
-
- // Cast the void src pointer to be the byte array we can work with.
- const unsigned char* sarray = (const unsigned char*) src;
-
- // The reusable round buffer
- unsigned int w[80];
-
- // Loop through all complete 64byte blocks.
- const int endOfFullBlocks = bytelength - 64;
- int endCurrentBlock;
- int currentBlock = 0;
-
- while (currentBlock <= endOfFullBlocks)
- {
- endCurrentBlock = currentBlock + 64;
-
- // Init the round buffer with the 64 byte block data.
- for (int roundPos = 0; currentBlock < endCurrentBlock; currentBlock += 4)
- {
- // This line will swap endian on big endian and keep endian on little endian.
- w[roundPos++] = (unsigned int) sarray[currentBlock + 3]
- | (((unsigned int) sarray[currentBlock + 2]) << 8)
- | (((unsigned int) sarray[currentBlock + 1]) << 16)
- | (((unsigned int) sarray[currentBlock]) << 24);
- }
- innerHash(result, w);
- }
-
- // Handle the last and not full 64 byte block if existing.
- endCurrentBlock = bytelength - currentBlock;
- clearWBuffert(w);
- int lastBlockBytes = 0;
- for (;lastBlockBytes < endCurrentBlock; ++lastBlockBytes)
- {
- w[lastBlockBytes >> 2] |= (unsigned int) sarray[lastBlockBytes + currentBlock] << ((3 - (lastBlockBytes & 3)) << 3);
- }
- w[lastBlockBytes >> 2] |= 0x80 << ((3 - (lastBlockBytes & 3)) << 3);
- if (endCurrentBlock >= 56)
- {
- innerHash(result, w);
- clearWBuffert(w);
- }
- w[15] = bytelength << 3;
- innerHash(result, w);
-
- // Store hash in result pointer, and make sure we get in in the correct order on both endian models.
- for (int hashByte = 20; --hashByte >= 0;)
- {
- hash[hashByte] = (result[hashByte >> 2] >> (((3 - hashByte) & 0x3) << 3)) & 0xff;
- }
- }
-
- void toHexString(const unsigned char* hash, char* hexstring)
- {
- const char hexDigits[] = { "0123456789abcdef" };
-
- for (int hashByte = 20; --hashByte >= 0;)
- {
- hexstring[hashByte << 1] = hexDigits[(hash[hashByte] >> 4) & 0xf];
- hexstring[(hashByte << 1) + 1] = hexDigits[hash[hashByte] & 0xf];
- }
- hexstring[40] = 0;
- }
-} // namespace sha1
+/*
+ sha1.cpp - source code of
+
+ ============
+ SHA-1 in C++
+ ============
+
+ 100% Public Domain.
+
+ Original C Code
+ -- Steve Reid <steve@edmweb.com>
+ Small changes to fit into bglibs
+ -- Bruce Guenter <bruce@untroubled.org>
+ Translation to simpler C++ Code
+ -- Volker Grabsch <vog@notjusthosting.com>
+*/
+
+#include "sha1.h"
+#include <sstream>
+#include <iomanip>
+#include <fstream>
+
+/* Help macros */
+#define SHA1_ROL(value, bits) (((value) << (bits)) | (((value) & 0xffffffff) >> (32 - (bits))))
+#define SHA1_BLK(i) (block[i&15] = SHA1_ROL(block[(i+13)&15] ^ block[(i+8)&15] ^ block[(i+2)&15] ^ block[i&15],1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define SHA1_R0(v,w,x,y,z,i) z += ((w&(x^y))^y) + block[i] + 0x5a827999 + SHA1_ROL(v,5); w=SHA1_ROL(w,30);
+#define SHA1_R1(v,w,x,y,z,i) z += ((w&(x^y))^y) + SHA1_BLK(i) + 0x5a827999 + SHA1_ROL(v,5); w=SHA1_ROL(w,30);
+#define SHA1_R2(v,w,x,y,z,i) z += (w^x^y) + SHA1_BLK(i) + 0x6ed9eba1 + SHA1_ROL(v,5); w=SHA1_ROL(w,30);
+#define SHA1_R3(v,w,x,y,z,i) z += (((w|x)&y)|(w&x)) + SHA1_BLK(i) + 0x8f1bbcdc + SHA1_ROL(v,5); w=SHA1_ROL(w,30);
+#define SHA1_R4(v,w,x,y,z,i) z += (w^x^y) + SHA1_BLK(i) + 0xca62c1d6 + SHA1_ROL(v,5); w=SHA1_ROL(w,30);
+
+SHA1::SHA1()
+{
+ reset();
+}
+
+
+void SHA1::update(const std::string &s)
+{
+ std::istringstream is(s);
+ update(is);
+}
+
+
+void SHA1::update(std::istream &is)
+{
+ std::string rest_of_buffer;
+ read(is, rest_of_buffer, BLOCK_BYTES - buffer.size());
+ buffer += rest_of_buffer;
+
+ while (is)
+ {
+ uint32 block[BLOCK_INTS];
+ buffer_to_block(buffer, block);
+ transform(block);
+ read(is, buffer, BLOCK_BYTES);
+ }
+}
+
+
+/*
+ * Add padding and return the message digest.
+ */
+
+std::string SHA1::final()
+{
+ /* Total number of hashed bits */
+ uint64 total_bits = (transforms*BLOCK_BYTES + buffer.size()) * 8;
+
+ /* Padding */
+ buffer += 0x80;
+ unsigned int orig_size = buffer.size();
+ while (buffer.size() < BLOCK_BYTES)
+ {
+ buffer += (char)0x00;
+ }
+
+ uint32 block[BLOCK_INTS];
+ buffer_to_block(buffer, block);
+
+ if (orig_size > BLOCK_BYTES - 8)
+ {
+ transform(block);
+ for (unsigned int i = 0; i < BLOCK_INTS - 2; i++)
+ {
+ block[i] = 0;
+ }
+ }
+
+ /* Append total_bits, split this uint64 into two uint32 */
+ block[BLOCK_INTS - 1] = total_bits;
+ block[BLOCK_INTS - 2] = (total_bits >> 32);
+ transform(block);
+
+ /* Hex std::string */
+ std::ostringstream result;
+ for (unsigned int i = 0; i < DIGEST_INTS; i++)
+ {
+ result << std::hex << std::setfill('0') << std::setw(8);
+ result << (digest[i] & 0xffffffff);
+ }
+
+ /* Reset for next run */
+ reset();
+
+ return result.str();
+}
+
+
+std::string SHA1::from_file(const std::string &filename)
+{
+ std::ifstream stream(filename.c_str(), std::ios::binary);
+ SHA1 checksum;
+ checksum.update(stream);
+ return checksum.final();
+}
+
+
+void SHA1::reset()
+{
+ /* SHA1 initialization constants */
+ digest[0] = 0x67452301;
+ digest[1] = 0xefcdab89;
+ digest[2] = 0x98badcfe;
+ digest[3] = 0x10325476;
+ digest[4] = 0xc3d2e1f0;
+
+ /* Reset counters */
+ transforms = 0;
+ buffer = "";
+}
+
+
+/*
+ * Hash a single 512-bit block. This is the core of the algorithm.
+ */
+
+void SHA1::transform(uint32 block[BLOCK_BYTES])
+{
+ /* Copy digest[] to working vars */
+ uint32 a = digest[0];
+ uint32 b = digest[1];
+ uint32 c = digest[2];
+ uint32 d = digest[3];
+ uint32 e = digest[4];
+
+
+ /* 4 rounds of 20 operations each. Loop unrolled. */
+ SHA1_R0(a,b,c,d,e, 0);
+ SHA1_R0(e,a,b,c,d, 1);
+ SHA1_R0(d,e,a,b,c, 2);
+ SHA1_R0(c,d,e,a,b, 3);
+ SHA1_R0(b,c,d,e,a, 4);
+ SHA1_R0(a,b,c,d,e, 5);
+ SHA1_R0(e,a,b,c,d, 6);
+ SHA1_R0(d,e,a,b,c, 7);
+ SHA1_R0(c,d,e,a,b, 8);
+ SHA1_R0(b,c,d,e,a, 9);
+ SHA1_R0(a,b,c,d,e,10);
+ SHA1_R0(e,a,b,c,d,11);
+ SHA1_R0(d,e,a,b,c,12);
+ SHA1_R0(c,d,e,a,b,13);
+ SHA1_R0(b,c,d,e,a,14);
+ SHA1_R0(a,b,c,d,e,15);
+ SHA1_R1(e,a,b,c,d,16);
+ SHA1_R1(d,e,a,b,c,17);
+ SHA1_R1(c,d,e,a,b,18);
+ SHA1_R1(b,c,d,e,a,19);
+ SHA1_R2(a,b,c,d,e,20);
+ SHA1_R2(e,a,b,c,d,21);
+ SHA1_R2(d,e,a,b,c,22);
+ SHA1_R2(c,d,e,a,b,23);
+ SHA1_R2(b,c,d,e,a,24);
+ SHA1_R2(a,b,c,d,e,25);
+ SHA1_R2(e,a,b,c,d,26);
+ SHA1_R2(d,e,a,b,c,27);
+ SHA1_R2(c,d,e,a,b,28);
+ SHA1_R2(b,c,d,e,a,29);
+ SHA1_R2(a,b,c,d,e,30);
+ SHA1_R2(e,a,b,c,d,31);
+ SHA1_R2(d,e,a,b,c,32);
+ SHA1_R2(c,d,e,a,b,33);
+ SHA1_R2(b,c,d,e,a,34);
+ SHA1_R2(a,b,c,d,e,35);
+ SHA1_R2(e,a,b,c,d,36);
+ SHA1_R2(d,e,a,b,c,37);
+ SHA1_R2(c,d,e,a,b,38);
+ SHA1_R2(b,c,d,e,a,39);
+ SHA1_R3(a,b,c,d,e,40);
+ SHA1_R3(e,a,b,c,d,41);
+ SHA1_R3(d,e,a,b,c,42);
+ SHA1_R3(c,d,e,a,b,43);
+ SHA1_R3(b,c,d,e,a,44);
+ SHA1_R3(a,b,c,d,e,45);
+ SHA1_R3(e,a,b,c,d,46);
+ SHA1_R3(d,e,a,b,c,47);
+ SHA1_R3(c,d,e,a,b,48);
+ SHA1_R3(b,c,d,e,a,49);
+ SHA1_R3(a,b,c,d,e,50);
+ SHA1_R3(e,a,b,c,d,51);
+ SHA1_R3(d,e,a,b,c,52);
+ SHA1_R3(c,d,e,a,b,53);
+ SHA1_R3(b,c,d,e,a,54);
+ SHA1_R3(a,b,c,d,e,55);
+ SHA1_R3(e,a,b,c,d,56);
+ SHA1_R3(d,e,a,b,c,57);
+ SHA1_R3(c,d,e,a,b,58);
+ SHA1_R3(b,c,d,e,a,59);
+ SHA1_R4(a,b,c,d,e,60);
+ SHA1_R4(e,a,b,c,d,61);
+ SHA1_R4(d,e,a,b,c,62);
+ SHA1_R4(c,d,e,a,b,63);
+ SHA1_R4(b,c,d,e,a,64);
+ SHA1_R4(a,b,c,d,e,65);
+ SHA1_R4(e,a,b,c,d,66);
+ SHA1_R4(d,e,a,b,c,67);
+ SHA1_R4(c,d,e,a,b,68);
+ SHA1_R4(b,c,d,e,a,69);
+ SHA1_R4(a,b,c,d,e,70);
+ SHA1_R4(e,a,b,c,d,71);
+ SHA1_R4(d,e,a,b,c,72);
+ SHA1_R4(c,d,e,a,b,73);
+ SHA1_R4(b,c,d,e,a,74);
+ SHA1_R4(a,b,c,d,e,75);
+ SHA1_R4(e,a,b,c,d,76);
+ SHA1_R4(d,e,a,b,c,77);
+ SHA1_R4(c,d,e,a,b,78);
+ SHA1_R4(b,c,d,e,a,79);
+
+ /* Add the working vars back into digest[] */
+ digest[0] += a;
+ digest[1] += b;
+ digest[2] += c;
+ digest[3] += d;
+ digest[4] += e;
+
+ /* Count the number of transformations */
+ transforms++;
+}
+
+
+void SHA1::buffer_to_block(const std::string &buffer, uint32 block[BLOCK_BYTES])
+{
+ /* Convert the std::string (byte buffer) to a uint32 array (MSB) */
+ for (unsigned int i = 0; i < BLOCK_INTS; i++)
+ {
+ block[i] = (buffer[4*i+3] & 0xff)
+ | (buffer[4*i+2] & 0xff)<<8
+ | (buffer[4*i+1] & 0xff)<<16
+ | (buffer[4*i+0] & 0xff)<<24;
+ }
+}
+
+
+void SHA1::read(std::istream &is, std::string &s, int max)
+{
+ char sbuf[max];
+ is.read(sbuf, max);
+ s.assign(sbuf, is.gcount());
+}
+
+
+std::string sha1(const std::string &string)
+{
+ SHA1 checksum;
+ checksum.update(string);
+ return checksum.final();
+}
diff --git a/libs/sha1/sha1.h b/libs/sha1/sha1.h
index 540c156d..15edee12 100644
--- a/libs/sha1/sha1.h
+++ b/libs/sha1/sha1.h
@@ -1,49 +1,57 @@
-/*
- Copyright (c) 2011, Micael Hildenborg
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
- * Neither the name of Micael Hildenborg nor the
- names of its contributors may be used to endorse or promote products
- derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY Micael Hildenborg ''AS IS'' AND ANY
- EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL Micael Hildenborg BE LIABLE FOR ANY
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef SHA1_DEFINED
-#define SHA1_DEFINED
-
-namespace sha1
-{
-
- /**
- @param src points to any kind of data to be hashed.
- @param bytelength the number of bytes to hash from the src pointer.
- @param hash should point to a buffer of at least 20 bytes of size for storing the sha1 result in.
- */
- void calc(const void* src, const int bytelength, unsigned char* hash);
-
- /**
- @param hash is 20 bytes of sha1 hash. This is the same data that is the result from the calc function.
- @param hexstring should point to a buffer of at least 41 bytes of size for storing the hexadecimal representation of the hash. A zero will be written at position 40, so the buffer will be a valid zero ended string.
- */
- void toHexString(const unsigned char* hash, char* hexstring);
-
-} // namespace sha1
-
-#endif // SHA1_DEFINED
+/*
+ sha1.h - header of
+
+ ============
+ SHA-1 in C++
+ ============
+
+ 100% Public Domain.
+
+ Original C Code
+ -- Steve Reid <steve@edmweb.com>
+ Small changes to fit into bglibs
+ -- Bruce Guenter <bruce@untroubled.org>
+ Translation to simpler C++ Code
+ -- Volker Grabsch <vog@notjusthosting.com>
+*/
+
+#ifndef SHA1_HPP
+#define SHA1_HPP
+
+
+#include <iostream>
+#include <string>
+
+class SHA1
+{
+public:
+ SHA1();
+ void update(const std::string &s);
+ void update(std::istream &is);
+ std::string final();
+ static std::string from_file(const std::string &filename);
+
+private:
+ typedef unsigned long int uint32; /* just needs to be at least 32bit */
+ typedef unsigned long long uint64; /* just needs to be at least 64bit */
+
+ static const unsigned int DIGEST_INTS = 5; /* number of 32bit integers per SHA1 digest */
+ static const unsigned int BLOCK_INTS = 16; /* number of 32bit integers per SHA1 block */
+ static const unsigned int BLOCK_BYTES = BLOCK_INTS * 4;
+
+ uint32 digest[DIGEST_INTS];
+ std::string buffer;
+ uint64 transforms;
+
+ void reset();
+ void transform(uint32 block[BLOCK_BYTES]);
+
+ static void buffer_to_block(const std::string &buffer, uint32 block[BLOCK_BYTES]);
+ static void read(std::istream &is, std::string &s, int max);
+};
+
+std::string sha1(const std::string &string);
+
+
+
+#endif /* SHA1_HPP */