Merge branch 'master' into mem-pool-improve

Author: Jim8y

src/Neo/Cryptography/Crypto.cs

@@ -233,6 +233,7 @@ public static byte[] GetMessageHash(byte[] message, HashAlgorithm hashAlgorithm
             return hashAlgorithm switch
             {
                 HashAlgorithm.SHA256 => message.Sha256(),
+                HashAlgorithm.SHA512 => message.Sha512(),
                 HashAlgorithm.Keccak256 => message.Keccak256(),
                 _ => throw new NotSupportedException(nameof(hashAlgorithm))
             };
@@ -249,6 +250,7 @@ public static byte[] GetMessageHash(ReadOnlySpan<byte> message, HashAlgorithm ha
             return hashAlgorithm switch
             {
                 HashAlgorithm.SHA256 => message.Sha256(),
+                HashAlgorithm.SHA512 => message.Sha512(),
                 HashAlgorithm.Keccak256 => message.Keccak256(),
                 _ => throw new NotSupportedException(nameof(hashAlgorithm))
             };

src/Neo/Cryptography/HashAlgorithm.cs

@@ -21,6 +21,11 @@ public enum HashAlgorithm : byte
         /// <summary>
         /// The Keccak256 hash algorithm.
         /// </summary>
-        Keccak256 = 0x01
+        Keccak256 = 0x01,
+
+        /// <summary>
+        /// The SHA512 hash algorithm.
+        /// </summary>
+        SHA512 = 0x02
     }
 }

src/Neo/Cryptography/Helper.cs

@@ -122,6 +122,22 @@ public static byte[] Sha256(this byte[] value)
 #endif
         }
 
+        /// <summary>
+        /// Computes the hash value for the specified byte array using the sha512 algorithm.
+        /// </summary>
+        /// <param name="value">The input to compute the hash code for.</param>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static byte[] Sha512(this byte[] value)
+        {
+#if !NET5_0_OR_GREATER
+            using var sha512 = SHA512.Create();
+            return sha512.ComputeHash(value);
+#else
+            return SHA512.HashData(value);
+#endif
+        }
+
         /// <summary>
         /// Computes the hash value for the specified region of the specified byte array using the sha256 algorithm.
         /// </summary>
@@ -140,6 +156,24 @@ public static byte[] Sha256(this byte[] value, int offset, int count)
 #endif
         }
 
+        /// <summary>
+        /// Computes the hash value for the specified region of the specified byte array using the sha512 algorithm.
+        /// </summary>
+        /// <param name="value">The input to compute the hash code for.</param>
+        /// <param name="offset">The offset into the byte array from which to begin using data.</param>
+        /// <param name="count">The number of bytes in the array to use as data.</param>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static byte[] Sha512(this byte[] value, int offset, int count)
+        {
+#if !NET5_0_OR_GREATER
+            using var sha512 = SHA512.Create();
+            return sha512.ComputeHash(value, offset, count);
+#else
+            return SHA512.HashData(value.AsSpan(offset, count));
+#endif
+        }
+
         /// <summary>
         /// Computes the hash value for the specified byte array using the sha256 algorithm.
         /// </summary>
@@ -148,7 +182,7 @@ public static byte[] Sha256(this byte[] value, int offset, int count)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static byte[] Sha256(this ReadOnlySpan<byte> value)
         {
-            byte[] buffer = new byte[32];
+            var buffer = new byte[32];
 #if !NET5_0_OR_GREATER
             using var sha256 = SHA256.Create();
             sha256.TryComputeHash(value, buffer, out _);
@@ -158,6 +192,24 @@ public static byte[] Sha256(this ReadOnlySpan<byte> value)
             return buffer;
         }
 
+        /// <summary>
+        /// Computes the hash value for the specified byte array using the sha512 algorithm.
+        /// </summary>
+        /// <param name="value">The input to compute the hash code for.</param>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static byte[] Sha512(this ReadOnlySpan<byte> value)
+        {
+            var buffer = new byte[64];
+#if !NET5_0_OR_GREATER
+            using var sha512 = SHA512.Create();
+            sha512.TryComputeHash(value, buffer, out _);
+#else
+            SHA512.HashData(value, buffer);
+#endif
+            return buffer;
+        }
+
         /// <summary>
         /// Computes the hash value for the specified byte array using the sha256 algorithm.
         /// </summary>
@@ -168,6 +220,16 @@ public static byte[] Sha256(this Span<byte> value)
             return Sha256((ReadOnlySpan<byte>)value);
         }
 
+        /// <summary>
+        /// Computes the hash value for the specified byte array using the sha512 algorithm.
+        /// </summary>
+        /// <param name="value">The input to compute the hash code for.</param>
+        /// <returns>The computed hash code.</returns>
+        public static byte[] Sha512(this Span<byte> value)
+        {
+            return Sha512((ReadOnlySpan<byte>)value);
+        }
+
         /// <summary>
         /// Computes the hash value for the specified byte array using the keccak256 algorithm.
         /// </summary>

tests/Neo.UnitTests/Cryptography/UT_Cryptography_Helper.cs

@@ -57,14 +57,25 @@ public void TestMurmurReadOnlySpan()
         [TestMethod]
         public void TestSha256()
         {
-            byte[] value = Encoding.ASCII.GetBytes("hello world");
-            byte[] result = value.Sha256(0, value.Length);
+            var value = Encoding.ASCII.GetBytes("hello world");
+            var result = value.Sha256(0, value.Length);
             Assert.AreEqual("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9", result.ToHexString());
             CollectionAssert.AreEqual(result, value.Sha256());
             CollectionAssert.AreEqual(result, ((Span<byte>)value).Sha256());
             CollectionAssert.AreEqual(result, ((ReadOnlySpan<byte>)value).Sha256());
         }
 
+        [TestMethod]
+        public void TestSha512()
+        {
+            var value = Encoding.ASCII.GetBytes("hello world");
+            var result = value.Sha512(0, value.Length);
+            Assert.AreEqual("309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f", result.ToHexString());
+            CollectionAssert.AreEqual(result, value.Sha512());
+            CollectionAssert.AreEqual(result, ((Span<byte>)value).Sha512());
+            CollectionAssert.AreEqual(result, ((ReadOnlySpan<byte>)value).Sha512());
+        }
+
         [TestMethod]
         public void TestKeccak256()
         {