Moved stand-alone libs to libs/ directory and added libs/subcircuit

2 files changed, 234 insertions, 0 deletions

diff --git a/libs/sha1/sha1.cpp b/libs/sha1/sha1.cpp
new file mode 100644
index 000000000..fb7bfed6f
--- /dev/null
+++ b/libs/sha1/sha1.cpp
@@ -0,0 +1,185 @@
+/*

+ 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

diff --git a/libs/sha1/sha1.h b/libs/sha1/sha1.h
new file mode 100644
index 000000000..540c156d1
--- /dev/null
+++ b/libs/sha1/sha1.h
@@ -0,0 +1,49 @@
+/*

+ 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