Murmur3 should not be cryptographic hash algorithm

src/Neo/Cryptography/Helper.cs

@@ -17,7 +17,6 @@
 using Org.BouncyCastle.Crypto.Modes;
 using Org.BouncyCastle.Crypto.Parameters;
 using System;
-using System.Buffers.Binary;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -63,8 +62,7 @@ public static byte[] RIPEMD160(this ReadOnlySpan<byte> value)
         /// <returns>The computed hash code.</returns>
         public static uint Murmur32(this byte[] value, uint seed)
         {
-            using Murmur32 murmur = new(seed);
-            return BinaryPrimitives.ReadUInt32LittleEndian(murmur.ComputeHash(value));
+            return Neo.Cryptography.Murmur32.HashToUInt32(value, seed);
         }
 
         /// <summary>
@@ -75,10 +73,7 @@ public static uint Murmur32(this byte[] value, uint seed)
         /// <returns>The computed hash code.</returns>
         public static uint Murmur32(this ReadOnlySpan<byte> value, uint seed)
         {
-            Span<byte> buffer = stackalloc byte[sizeof(uint)];
-            using Murmur32 murmur = new(seed);
-            murmur.TryComputeHash(value, buffer, out _);
-            return BinaryPrimitives.ReadUInt32LittleEndian(buffer);
+            return Neo.Cryptography.Murmur32.HashToUInt32(value, seed);
         }
 
         /// <summary>

src/Neo/Cryptography/Murmur32.cs

@@ -11,13 +11,15 @@
 
 using System;
 using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
 
 namespace Neo.Cryptography
 {
     /// <summary>
     /// Computes the murmur hash for the input data.
+    /// <remarks>Murmur32 is a non-cryptographic hash function.</remarks>
     /// </summary>
-    public sealed class Murmur32 : System.Security.Cryptography.HashAlgorithm
+    public sealed class Murmur32
     {
         private const uint c1 = 0xcc9e2d51;
         private const uint c2 = 0x1b873593;
@@ -26,41 +28,40 @@ public sealed class Murmur32 : System.Security.Cryptography.HashAlgorithm
         private const uint m = 5;
         private const uint n = 0xe6546b64;
 
-        private readonly uint seed;
-        private uint hash;
-        private int length;
+        private readonly uint _seed;
+        private uint _hash;
+        private int _length;
 
         public const int HashSizeInBits = 32;
-        public override int HashSize => HashSizeInBits;
+
+        [Obsolete("Use HashSizeInBits")]
+        public int HashSize => HashSizeInBits;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Murmur32"/> class with the specified seed.
         /// </summary>
         /// <param name="seed">The seed to be used.</param>
         public Murmur32(uint seed)
         {
-            this.seed = seed;
-            HashSizeValue = HashSizeInBits;
-            Initialize();
-        }
-
-        protected override void HashCore(byte[] array, int ibStart, int cbSize)
-        {
-            HashCore(array.AsSpan(ibStart, cbSize));
+            _seed = seed;
         }
 
-        protected override void HashCore(ReadOnlySpan<byte> source)
+        /// <summary>
+        /// Append data to murmur computation
+        /// </summary>
+        /// <param name="source">Source</param>
+        public void Append(ReadOnlySpan<byte> source)
         {
-            length += source.Length;
+            _length += source.Length;
             for (; source.Length >= 4; source = source[4..])
             {
-                uint k = BinaryPrimitives.ReadUInt32LittleEndian(source);
+                var k = BinaryPrimitives.ReadUInt32LittleEndian(source);
                 k *= c1;
                 k = Helper.RotateLeft(k, r1);
                 k *= c2;
-                hash ^= k;
-                hash = Helper.RotateLeft(hash, r2);
-                hash = hash * m + n;
+                _hash ^= k;
+                _hash = Helper.RotateLeft(_hash, r2);
+                _hash = _hash * m + n;
             }
             if (source.Length > 0)
             {
@@ -74,34 +75,61 @@ protected override void HashCore(ReadOnlySpan<byte> source)
                 remainingBytes *= c1;
                 remainingBytes = Helper.RotateLeft(remainingBytes, r1);
                 remainingBytes *= c2;
-                hash ^= remainingBytes;
+                _hash ^= remainingBytes;
             }
         }
 
-        protected override byte[] HashFinal()
+        private uint GetCurrentHashUInt32()
         {
-            byte[] buffer = new byte[sizeof(uint)];
-            TryHashFinal(buffer, out _);
-            return buffer;
+            var state = _hash ^ (uint)_length;
+            state ^= state >> 16;
+            state *= 0x85ebca6b;
+            state ^= state >> 13;
+            state *= 0xc2b2ae35;
+            state ^= state >> 16;
+            return state;
         }
 
-        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Initialize()
         {
-            hash ^= (uint)length;
-            hash ^= hash >> 16;
-            hash *= 0x85ebca6b;
-            hash ^= hash >> 13;
-            hash *= 0xc2b2ae35;
-            hash ^= hash >> 16;
+            _hash = _seed;
+            _length = 0;
+        }
 
-            bytesWritten = Math.Min(destination.Length, sizeof(uint));
-            return BinaryPrimitives.TryWriteUInt32LittleEndian(destination, hash);
+        /// <summary>
+        /// Computes the murmur hash for the input data and resets the state.
+        /// </summary>
+        /// <param name="data">The input to compute the hash code for.</param>
+        /// <returns>The computed hash code in byte[4].</returns>
+        public byte[] ComputeHash(ReadOnlySpan<byte> data)
+        {
+            var buffer = new byte[HashSizeInBits / 8];
+            BinaryPrimitives.WriteUInt32LittleEndian(buffer, ComputeHashUInt32(data));
+            return buffer;
         }
 
-        public override void Initialize()
+        /// <summary>
+        /// Computes the murmur hash for the input data and resets the state.
+        /// </summary>
+        /// <param name="data">The input to compute the hash code for.</param>
+        /// <returns>The computed hash code in uint.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint ComputeHashUInt32(ReadOnlySpan<byte> data)
         {
-            hash = seed;
-            length = 0;
+            Initialize();
+            Append(data);
+            return GetCurrentHashUInt32();
         }
+
+        /// <summary>
+        /// Computes the murmur hash for the input data.
+        /// </summary>
+        /// <param name="data">The input to compute the hash code for.</param>
+        /// <param name="seed">The seed used by the murmur algorithm.</param>
+        /// <returns>The computed hash code in uint.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint HashToUInt32(ReadOnlySpan<byte> data, uint seed)
+            => new Murmur32(seed).ComputeHashUInt32(data);
     }
 }

src/Neo/SmartContract/Native/CryptoLib.cs

@@ -62,7 +62,7 @@ public static byte[] Sha256(byte[] data)
         [ContractMethod(CpuFee = 1 << 13)]
         public static byte[] Murmur32(byte[] data, uint seed)
         {
-            using Murmur32 murmur = new(seed);
+            Murmur32 murmur = new(seed);
             return murmur.ComputeHash(data);
         }
 

tests/Neo.UnitTests/Cryptography/UT_Murmur32.cs

@@ -22,29 +22,32 @@ public class UT_Murmur32
         [TestMethod]
         public void TestGetHashSize()
         {
-            Murmur32 murmur3 = new Murmur32(1);
-            murmur3.HashSize.Should().Be(32);
+            Murmur32.HashSizeInBits.Should().Be(32);
         }
 
         [TestMethod]
-        public void TestHashCore()
+        public void TestHashToUInt32()
         {
             byte[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1 };
             array.Murmur32(10u).Should().Be(378574820u);
         }
 
         [TestMethod]
-        public void TestTryComputeHash()
+        public void TestComputeHash()
         {
             var murmur3 = new Murmur32(10u);
-            var buffer = new byte[murmur3.HashSize / 8];
             var data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1 };
-
-            var ok = murmur3.TryComputeHash(data, buffer, out _);
-            ok.Should().BeTrue();
-
+            var buffer = murmur3.ComputeHash(data);
             var hash = BinaryPrimitives.ReadUInt32LittleEndian(buffer);
             hash.Should().Be(378574820u);
         }
+
+        [TestMethod]
+        public void TestComputeHashUInt32()
+        {
+            var murmur3 = new Murmur32(10u);
+            var hash = murmur3.ComputeHashUInt32("hello worldhello world"u8.ToArray());
+            hash.Should().Be(60539726u);
+        }
     }
 }