Replaced sha1 implementation

diff --git a/frontends/ast/ast.cc b/frontends/ast/ast.cc
index 46b717ce008504c898c0da145cc41ab91c813f95..85b67b65e27d061758e749a0e7908b8c83e6a40d 100644 (file)
--- a/frontends/ast/ast.cc
+++ b/frontends/ast/ast.cc
@@ -979,10 +979,6 @@ RTLIL::IdString AstModule::derive(RTLIL::Design *design, std::map<RTLIL::IdStrin
        use_internal_line_num();
 
        std::string para_info;
-       std::vector<unsigned char> hash_data;
-       hash_data.insert(hash_data.end(), stripped_name.begin(), stripped_name.end());
-       hash_data.push_back(0);
-
        AstNode *new_ast = ast->clone();
 
        int para_counter = 0;
@@ -999,10 +995,6 @@ RTLIL::IdString AstModule::derive(RTLIL::Design *design, std::map<RTLIL::IdStrin
                        para_info += stringf("%s=%s", child->str.c_str(), log_signal(RTLIL::SigSpec(parameters[para_id])));
                        delete child->children.at(0);
                        child->children[0] = AstNode::mkconst_bits(parameters[para_id].bits, (parameters[para_id].flags & RTLIL::CONST_FLAG_SIGNED) != 0);
-                       hash_data.insert(hash_data.end(), child->str.begin(), child->str.end());
-                       hash_data.push_back(0);
-                       hash_data.insert(hash_data.end(), parameters[para_id].bits.begin(), parameters[para_id].bits.end());
-                       hash_data.push_back(0xff);
                        parameters.erase(para_id);
                        continue;
                }
@@ -1018,28 +1010,11 @@ RTLIL::IdString AstModule::derive(RTLIL::Design *design, std::map<RTLIL::IdStrin
        std::string modname;
 
        if (orig_parameters_n == 0)
-       {
                modname = stripped_name;
-       }
-       else
-       if (para_info.size() > 60)
-       {
-               unsigned char hash[20];
-               unsigned char *hash_data2 = new unsigned char[hash_data.size()];
-               for (size_t i = 0; i < hash_data.size(); i++)
-                       hash_data2[i] = hash_data[i];
-               sha1::calc(hash_data2, hash_data.size(), hash);
-               delete[] hash_data2;
-
-               char hexstring[41];
-               sha1::toHexString(hash, hexstring);
-
-               modname = "$paramod$" + std::string(hexstring) + stripped_name;
-       }
+       else if (para_info.size() > 60)
+               modname = "$paramod$" + sha1(para_info) + stripped_name;
        else
-       {
                modname = "$paramod" + stripped_name + para_info;
-       }
 
        if (!design->has(modname)) {
                new_ast->str = modname;

diff --git a/libs/sha1/sha1.cpp b/libs/sha1/sha1.cpp
index fb7bfed6f17c2703f7e18d5bd827e1e94ec2a555..dc86b2ce2cf8884152bac0d5fb43ab036a43319f 100644 (file)
--- a/libs/sha1/sha1.cpp
+++ b/libs/sha1/sha1.cpp
@@ -1,185 +1,270 @@
-/*\r
- Copyright (c) 2011, Micael Hildenborg\r
- All rights reserved.\r
-\r
- Redistribution and use in source and binary forms, with or without\r
- modification, are permitted provided that the following conditions are met:\r
-    * Redistributions of source code must retain the above copyright\r
-      notice, this list of conditions and the following disclaimer.\r
-    * Redistributions in binary form must reproduce the above copyright\r
-      notice, this list of conditions and the following disclaimer in the\r
-      documentation and/or other materials provided with the distribution.\r
-    * Neither the name of Micael Hildenborg nor the\r
-      names of its contributors may be used to endorse or promote products\r
-      derived from this software without specific prior written permission.\r
-\r
- THIS SOFTWARE IS PROVIDED BY Micael Hildenborg ''AS IS'' AND ANY\r
- EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
- DISCLAIMED. IN NO EVENT SHALL Micael Hildenborg BE LIABLE FOR ANY\r
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
- */\r
-\r
-/*\r
- Contributors:\r
- Gustav\r
- Several members in the gamedev.se forum.\r
- Gregory Petrosyan\r
- */\r
-\r
-#include "sha1.h"\r
-\r
-namespace sha1\r
-{\r
-    namespace // local\r
-    {\r
-        // Rotate an integer value to left.\r
-        inline unsigned int rol(const unsigned int value,\r
-                const unsigned int steps)\r
-        {\r
-            return ((value << steps) | (value >> (32 - steps)));\r
-        }\r
-\r
-        // Sets the first 16 integers in the buffert to zero.\r
-        // Used for clearing the W buffert.\r
-        inline void clearWBuffert(unsigned int* buffert)\r
-        {\r
-            for (int pos = 16; --pos >= 0;)\r
-            {\r
-                buffert[pos] = 0;\r
-            }\r
-        }\r
-\r
-        void innerHash(unsigned int* result, unsigned int* w)\r
-        {\r
-            unsigned int a = result[0];\r
-            unsigned int b = result[1];\r
-            unsigned int c = result[2];\r
-            unsigned int d = result[3];\r
-            unsigned int e = result[4];\r
-\r
-            int round = 0;\r
-\r
-            #define sha1macro(func,val) \\r
-                       { \\r
-                const unsigned int t = rol(a, 5) + (func) + e + val + w[round]; \\r
-                               e = d; \\r
-                               d = c; \\r
-                               c = rol(b, 30); \\r
-                               b = a; \\r
-                               a = t; \\r
-                       }\r
-\r
-            while (round < 16)\r
-            {\r
-                sha1macro((b & c) | (~b & d), 0x5a827999)\r
-                ++round;\r
-            }\r
-            while (round < 20)\r
-            {\r
-                w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);\r
-                sha1macro((b & c) | (~b & d), 0x5a827999)\r
-                ++round;\r
-            }\r
-            while (round < 40)\r
-            {\r
-                w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);\r
-                sha1macro(b ^ c ^ d, 0x6ed9eba1)\r
-                ++round;\r
-            }\r
-            while (round < 60)\r
-            {\r
-                w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);\r
-                sha1macro((b & c) | (b & d) | (c & d), 0x8f1bbcdc)\r
-                ++round;\r
-            }\r
-            while (round < 80)\r
-            {\r
-                w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);\r
-                sha1macro(b ^ c ^ d, 0xca62c1d6)\r
-                ++round;\r
-            }\r
-\r
-            #undef sha1macro\r
-\r
-            result[0] += a;\r
-            result[1] += b;\r
-            result[2] += c;\r
-            result[3] += d;\r
-            result[4] += e;\r
-        }\r
-    } // namespace\r
-\r
-    void calc(const void* src, const int bytelength, unsigned char* hash)\r
-    {\r
-        // Init the result array.\r
-        unsigned int result[5] = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 };\r
-\r
-        // Cast the void src pointer to be the byte array we can work with.\r
-        const unsigned char* sarray = (const unsigned char*) src;\r
-\r
-        // The reusable round buffer\r
-        unsigned int w[80];\r
-\r
-        // Loop through all complete 64byte blocks.\r
-        const int endOfFullBlocks = bytelength - 64;\r
-        int endCurrentBlock;\r
-        int currentBlock = 0;\r
-\r
-        while (currentBlock <= endOfFullBlocks)\r
-        {\r
-            endCurrentBlock = currentBlock + 64;\r
-\r
-            // Init the round buffer with the 64 byte block data.\r
-            for (int roundPos = 0; currentBlock < endCurrentBlock; currentBlock += 4)\r
-            {\r
-                // This line will swap endian on big endian and keep endian on little endian.\r
-                w[roundPos++] = (unsigned int) sarray[currentBlock + 3]\r
-                        | (((unsigned int) sarray[currentBlock + 2]) << 8)\r
-                        | (((unsigned int) sarray[currentBlock + 1]) << 16)\r
-                        | (((unsigned int) sarray[currentBlock]) << 24);\r
-            }\r
-            innerHash(result, w);\r
-        }\r
-\r
-        // Handle the last and not full 64 byte block if existing.\r
-        endCurrentBlock = bytelength - currentBlock;\r
-        clearWBuffert(w);\r
-        int lastBlockBytes = 0;\r
-        for (;lastBlockBytes < endCurrentBlock; ++lastBlockBytes)\r
-        {\r
-            w[lastBlockBytes >> 2] |= (unsigned int) sarray[lastBlockBytes + currentBlock] << ((3 - (lastBlockBytes & 3)) << 3);\r
-        }\r
-        w[lastBlockBytes >> 2] |= 0x80 << ((3 - (lastBlockBytes & 3)) << 3);\r
-        if (endCurrentBlock >= 56)\r
-        {\r
-            innerHash(result, w);\r
-            clearWBuffert(w);\r
-        }\r
-        w[15] = bytelength << 3;\r
-        innerHash(result, w);\r
-\r
-        // Store hash in result pointer, and make sure we get in in the correct order on both endian models.\r
-        for (int hashByte = 20; --hashByte >= 0;)\r
-        {\r
-            hash[hashByte] = (result[hashByte >> 2] >> (((3 - hashByte) & 0x3) << 3)) & 0xff;\r
-        }\r
-    }\r
-\r
-    void toHexString(const unsigned char* hash, char* hexstring)\r
-    {\r
-        const char hexDigits[] = { "0123456789abcdef" };\r
-\r
-        for (int hashByte = 20; --hashByte >= 0;)\r
-        {\r
-            hexstring[hashByte << 1] = hexDigits[(hash[hashByte] >> 4) & 0xf];\r
-            hexstring[(hashByte << 1) + 1] = hexDigits[hash[hashByte] & 0xf];\r
-        }\r
-        hexstring[40] = 0;\r
-    }\r
-} // namespace sha1\r
+/*
+    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 540c156d1421bab3b0ab8d943ace86b3f15d5b21..15edee12e6784bc377a0597dd898b859303ed5d6 100644 (file)
--- a/libs/sha1/sha1.h
+++ b/libs/sha1/sha1.h
@@ -1,49 +1,57 @@
-/*\r
- Copyright (c) 2011, Micael Hildenborg\r
- All rights reserved.\r
-\r
- Redistribution and use in source and binary forms, with or without\r
- modification, are permitted provided that the following conditions are met:\r
-    * Redistributions of source code must retain the above copyright\r
-      notice, this list of conditions and the following disclaimer.\r
-    * Redistributions in binary form must reproduce the above copyright\r
-      notice, this list of conditions and the following disclaimer in the\r
-      documentation and/or other materials provided with the distribution.\r
-    * Neither the name of Micael Hildenborg nor the\r
-      names of its contributors may be used to endorse or promote products\r
-      derived from this software without specific prior written permission.\r
-\r
- THIS SOFTWARE IS PROVIDED BY Micael Hildenborg ''AS IS'' AND ANY\r
- EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
- DISCLAIMED. IN NO EVENT SHALL Micael Hildenborg BE LIABLE FOR ANY\r
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
- */\r
-\r
-#ifndef SHA1_DEFINED\r
-#define SHA1_DEFINED\r
-\r
-namespace sha1\r
-{\r
-\r
-    /**\r
-     @param src points to any kind of data to be hashed.\r
-     @param bytelength the number of bytes to hash from the src pointer.\r
-     @param hash should point to a buffer of at least 20 bytes of size for storing the sha1 result in.\r
-     */\r
-    void calc(const void* src, const int bytelength, unsigned char* hash);\r
-\r
-    /**\r
-     @param hash is 20 bytes of sha1 hash. This is the same data that is the result from the calc function.\r
-     @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.\r
-     */\r
-    void toHexString(const unsigned char* hash, char* hexstring);\r
-\r
-} // namespace sha1\r
-\r
-#endif // SHA1_DEFINED\r
+/*
+    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 */

diff --git a/manual/CHAPTER_Auxlibs.tex b/manual/CHAPTER_Auxlibs.tex
index 0726e031f225cc624d7d79c3faf25ef521ad2c4f..8d3ed743030c115800239a6d02889c7c07ad66f9 100644 (file)
--- a/manual/CHAPTER_Auxlibs.tex
+++ b/manual/CHAPTER_Auxlibs.tex
@@ -6,9 +6,9 @@ with Yosys.
 
 \section{SHA1}
 
-The files in {\tt libs/sha1/} provide a SHA1 implementation written by Micael
-Hildenborg \citeweblink{smallsha1}. It is used for generating unique names when
-specializing parameterized modules.
+The files in {\tt libs/sha1/} provide a public domain SHA1 implementation written
+by Steve Reid, Bruce Guenter, and Volker Grabsch. It is used for generating
+unique names when specializing parameterized modules.
 
 \section{BigInt}
 

diff --git a/manual/weblinks.bib b/manual/weblinks.bib
index 9b6032edba838fcedb4314bccaf8dda496768e89..5215a6ca34409f0a33e7ac267309f6670ca6f757 100644 (file)
--- a/manual/weblinks.bib
+++ b/manual/weblinks.bib
@@ -132,9 +132,3 @@
        note = {\url{http://mattmccutchen.net/bigint/}}\r
 }\r
 \r
-@misc{smallsha1,\r
-       author = {Micael Hildenborg},\r
-       title = {{smallsha1}},\r
-       note = {\url{https://code.google.com/p/smallsha1/}}\r
-}\r
-\r

diff --git a/passes/opt/opt_reduce.cc b/passes/opt/opt_reduce.cc
index 80ec89744a50b02622ebd8a5acb90cda751f2663..f947e9724e19783ed23951a2fdd0c394df15b82d 100644 (file)
--- a/passes/opt/opt_reduce.cc
+++ b/passes/opt/opt_reduce.cc
@@ -22,7 +22,6 @@
 #include "kernel/sigtools.h"
 #include "kernel/log.h"
 #include "kernel/celltypes.h"
-#include "libs/sha1/sha1.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <set>

diff --git a/passes/opt/opt_share.cc b/passes/opt/opt_share.cc
index 26d19414ac7b21fbf5f9ec5b62aacf8ffa3a95f7..3532b124e4c5f9a5f5403c2f137c7a38918aab0f 100644 (file)
--- a/passes/opt/opt_share.cc
+++ b/passes/opt/opt_share.cc
@@ -107,12 +107,7 @@ struct OptShareWorker
                        hash_string += "\n";
                }
 
-               unsigned char hash[20];
-               char hash_hex_string[41];
-               sha1::calc(hash_string.c_str(), hash_string.size(), hash);
-               sha1::toHexString(hash, hash_hex_string);
-               cell_hash_cache[cell] = hash_hex_string;
-
+               cell_hash_cache[cell] = sha1(hash_string);
                return cell_hash_cache[cell];
        }
 #endif

diff --git a/passes/techmap/techmap.cc b/passes/techmap/techmap.cc
index c2e5960ffb13cf843484ff86295139cc3ba8ebf1..1f812e52fe99a6481afa035c9745e1e128fb4f35 100644 (file)
--- a/passes/techmap/techmap.cc
+++ b/passes/techmap/techmap.cc
@@ -99,12 +99,7 @@ struct TechmapWorker
                                        connbits_map[bit] = std::pair<std::string, int>(conn.first, i);stringf("%s %d", log_id(conn.first), i, bit.data);
                        }
 
-               unsigned char hash[20];
-               char hash_hex_string[41];
-               sha1::calc(constmap_info.c_str(), constmap_info.size(), hash);
-               sha1::toHexString(hash, hash_hex_string);
-
-               return stringf("$paramod$constmap$%s%s", hash_hex_string, tpl->name.c_str());
+               return stringf("$paramod$constmap:%s%s", sha1(constmap_info).c_str(), tpl->name.c_str());
        }
 
        TechmapWires techmap_find_special_wires(RTLIL::Module *module)