Merge pull request #47 from GabrielTofvesson/master

Non-allocating hashing

Author: TwoTenPvP

MLAPI/Data/NetworkConfig.cs

@@ -1,5 +1,6 @@
+using MLAPI.NetworkingManagerComponents.Binary;
+using MLAPI.NetworkingManagerComponents.Cryptography;
 using MLAPI.Data.Transports.UNET;
-using MLAPI.NetworkingManagerComponents.Binary;
 using System;
 using System.Collections.Generic;
 using System.Security.Cryptography;
@@ -180,16 +181,16 @@ public byte[] GetConfig(bool cache = true)
                 writer.WriteBool(EnableSceneSwitching);
                 writer.WriteBool(SignKeyExchange);
 
-                using (SHA256Managed sha256 = new SHA256Managed())
-                {
-                    //Returns a 256 bit / 32 byte long checksum of the config
+                //using (SHA256Managed sha256 = new SHA256Managed())
+                //{
+                    // Returns a 160 bit / 20 byte / 5 int checksum of the config
                     if (cache)
                     {
-                        ConfigHash = sha256.ComputeHash(writer.Finalize());
+                        ConfigHash = MessageDigest.SHA1_Opt(writer.Finalize()).ToArray(); //sha256.ComputeHash(writer.Finalize());
                         return ConfigHash;
                     }
-                    return sha256.ComputeHash(writer.Finalize());
-                }
+                    return MessageDigest.SHA1_Opt(writer.Finalize()).ToArray(); //sha256.ComputeHash(writer.Finalize());
+                //}
             }
         }
 

MLAPI/MLAPI.csproj

@@ -108,6 +108,7 @@
     <Compile Include="NetworkingManagerComponents\Core\NetworkPoolManager.cs" />
     <Compile Include="NetworkingManagerComponents\Core\NetworkSceneManager.cs" />
     <Compile Include="NetworkingManagerComponents\Core\SpawnManager.cs" />
+    <Compile Include="NetworkingManagerComponents\Cryptography\MessageDigest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Data\Transports\UNET\NetId.cs" />
     <Compile Include="NetworkingManagerComponents\Binary\MessageChunker.cs" />

MLAPI/NetworkingManagerComponents/Binary/PrimitiveHasher.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using MLAPI.NetworkingManagerComponents.Cryptography;
+using System.Collections.Generic;
 using System.Security.Cryptography;
 using System.Text;
 
@@ -15,44 +16,44 @@ public static ulong GetULongHash(string input, bool cache = false)
             if (cache && ulongCachedHashes.ContainsKey(input))
                 return ulongCachedHashes[input];
 
-            using (SHA256Managed sha = new SHA256Managed())
-            {
-                byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
-                ulong value =  hash[0] | ((ulong)hash[1] << 8) | ((ulong)hash[2] << 16) | ((ulong)hash[3] << 24) | ((ulong)hash[4] << 32) | ((ulong)hash[5] << 40) | ((ulong)hash[6] << 48) | ((ulong)hash[7] << 56);
+            //using (SHA256Managed sha = new SHA256Managed())
+            //{
+                //byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
+                ulong value = MessageDigest.SHA1_Opt(Encoding.UTF8.GetBytes(input)).CastULong(); //hash[0] | ((ulong)hash[1] << 8) | ((ulong)hash[2] << 16) | ((ulong)hash[3] << 24) | ((ulong)hash[4] << 32) | ((ulong)hash[5] << 40) | ((ulong)hash[6] << 48) | ((ulong)hash[7] << 56);
                 if (cache)
                     ulongCachedHashes.Add(input, value);
                 return value;
-            }
+            //}
         }
 
         public static ulong GetUIntHash(string input, bool cache = false)
         {
             if (cache && uintCachedHashes.ContainsKey(input))
                 return uintCachedHashes[input];
 
-            using (SHA256Managed sha = new SHA256Managed())
-            {
-                byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
-                uint value = hash[0] | ((uint)hash[1] << 8) | ((uint)hash[2] << 16) | ((uint)hash[3] << 24);
+            //using (SHA256Managed sha = new SHA256Managed())
+            //{
+                //byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
+                uint value = MessageDigest.SHA1_Opt(Encoding.UTF8.GetBytes(input)).CastUInt(); //hash[0] | ((uint)hash[1] << 8) | ((uint)hash[2] << 16) | ((uint)hash[3] << 24);
                 if (cache)
                     uintCachedHashes.Add(input, value);
                 return value;
-            }
+            //}
         }
 
         public static ushort GetUShortHash(string input, bool cache = false)
         {
             if (cache && ushortCachedHashes.ContainsKey(input))
                 return ushortCachedHashes[input];
 
-            using (SHA256Managed sha = new SHA256Managed())
-            {
-                byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
-                ushort value = (ushort)(hash[0] | (ushort)(hash[1] << 8));
+            //using (SHA256Managed sha = new SHA256Managed())
+            //{
+            //byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
+                ushort value = MessageDigest.SHA1_Opt(Encoding.UTF8.GetBytes(input)).CastUShort(); //(ushort)(hash[0] | (ushort)(hash[1] << 8));
                 if (cache)
                     ushortCachedHashes.Add(input, value);
                 return value;
-            }
+            //}
         }
     }
 }

MLAPI/NetworkingManagerComponents/Cryptography/MessageDigest.cs

@@ -0,0 +1,123 @@
+using MLAPI.NetworkingManagerComponents.Binary;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace MLAPI.NetworkingManagerComponents.Cryptography
+{
+    public static class MessageDigest
+    {
+        public struct SHA1Result
+        {
+            public uint i0, i1, i2, i3, i4;
+            public byte Get(int idx) => (byte)((idx < 4 ? i0 : idx < 8 ? i1 : idx < 12 ? i2 : idx < 16 ? i3 : i4) >> (8 * (idx % 4)));
+            public byte[] ToArray()
+            {
+                byte[] b = new byte[20];
+                for (int i = 0; i < 20; ++i) b[i] = Get(i);
+                return b;
+            }
+            private ulong Collect(int bytes)
+            {
+                ulong u = 0;
+                for (int i = 0; i < bytes; ++i) u |= (ulong)Get(i) << (8*i);
+                return u;
+            }
+            public byte CastByte() => Get(0);
+            public ushort CastUShort() => (ushort)Collect(2);
+            public uint CastUInt() => (uint)Collect(4);
+            public ulong CastULong() => (ulong)Collect(8);
+        }
+        public static SHA1Result SHA1_Opt(byte[] message)
+        {
+            SHA1Result result = new SHA1Result
+            {
+                // Initialize buffers
+                i0 = 0x67452301,
+                i1 = 0xEFCDAB89,
+                i2 = 0x98BADCFE,
+                i3 = 0x10325476,
+                i4 = 0xC3D2E1F0
+            };
+
+            // Pad message
+            long len = message.Length * 8;
+            int
+                ml = message.Length + 1,
+                max = ml + ((960 - (ml * 8 % 512)) % 512) / 8 + 8;
+
+            // Replaces the allocation of a lot of bytes
+            byte GetMsg(int idx)
+            {
+                if (idx < message.Length)
+                    return message[idx];
+                else if (idx == message.Length)
+                    return 0x80;
+                else if (max - idx <= 8)
+                    return (byte)((len >> ((max - 1 - idx) * 8)) & 255);
+                return 0;
+            }
+
+            int chunks = max / 64;
+
+            // Replaces the recurring allocation of 80 uints
+            uint ComputeIndex(int block, int idx)
+            {
+                if (idx < 16)
+                    return (uint)((GetMsg(block * 64 + idx * 4) << 24) | (GetMsg(block * 64 + idx * 4 + 1) << 16) | (GetMsg(block * 64 + idx * 4 + 2) << 8) | (GetMsg(block * 64 + idx * 4 + 3) << 0));
+                else
+                    return Rot(ComputeIndex(block, idx - 3) ^ ComputeIndex(block, idx - 8) ^ ComputeIndex(block, idx - 14) ^ ComputeIndex(block, idx - 16), 1);
+            }
+
+            // Perform hashing for each 512-bit block
+            for (int i = 0; i < chunks; ++i)
+            {
+
+                // Initialize chunk-hash
+                uint
+                    a = result.i0,
+                    b = result.i1,
+                    c = result.i2,
+                    d = result.i3,
+                    e = result.i4;
+
+                // Do hash rounds
+                for (int t = 0; t < 80; ++t)
+                {
+                    uint tmp = Rot(a, 5) + func(t, b, c, d) + e + K(t) + ComputeIndex(i, t);
+                    e = d;
+                    d = c;
+                    c = Rot(b, 30);
+                    b = a;
+                    a = tmp;
+                }
+                result.i0 += a;
+                result.i1 += b;
+                result.i2 += c;
+                result.i3 += d;
+                result.i4 += e;
+            }
+            result.i0 = BinaryHelpers.SwapEndian(result.i0);
+            result.i1 = BinaryHelpers.SwapEndian(result.i1);
+            result.i2 = BinaryHelpers.SwapEndian(result.i2);
+            result.i3 = BinaryHelpers.SwapEndian(result.i3);
+            result.i4 = BinaryHelpers.SwapEndian(result.i4);
+            return result;
+        }
+
+        private static uint func(int t, uint b, uint c, uint d) =>
+            t < 20 ? (b & c) | ((~b) & d) :
+            t < 40 ? b ^ c ^ d :
+            t < 60 ? (b & c) | (b & d) | (c & d) :
+            /*t<80*/ b ^ c ^ d;
+
+        private static uint K(int t) =>
+            t < 20 ? 0x5A827999 :
+            t < 40 ? 0x6ED9EBA1 :
+            t < 60 ? 0x8F1BBCDC :
+            /*t<80*/ 0xCA62C1D6;
+
+        private static uint Rot(uint val, int by) => (val << by) | (val >> (32 - by));
+    }
+}