feature/v2

 - Added HMAC implementation.

Author: MrMatthewLayton

OnixLabs.Playground/Program.cs

@@ -23,13 +23,14 @@ internal static class Program
     {
         private static void Main(string[] args)
         {
-            byte[] key = Encoding.ASCII.GetBytes("Test");
-            byte[] data = Encoding.ASCII.GetBytes("Hello, World!");
+            Hmac hmac = Hmac.ComputeSha2Hmac256("Hello, World!", "Test key");
+            Console.WriteLine(hmac.ToStringWithAlgorithmType());
 
-            using HMAC hmac = new HMACSHA256(key);
-            byte[] result = hmac.ComputeHash(data);
+            Hmac hmac2 = Hmac.Parse(hmac.ToStringWithAlgorithmType());
 
-            Console.WriteLine(Hash.FromByteArray(result));
+            Console.WriteLine(hmac2.ToStringWithAlgorithmType());
+            
+            Console.WriteLine(hmac == hmac2);
         }
     }
 }

OnixLabs.Security.Cryptography.UnitTests/HmacTests.cs

@@ -0,0 +1,69 @@
+// Copyright 2020-2021 ONIXLabs
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//    http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Xunit;
+
+namespace OnixLabs.Security.Cryptography.UnitTests
+{
+    public sealed class HmacTests
+    {
+        [Fact(DisplayName = "Identical HMACs should be considered equal")]
+        public void IdenticalHashesShouldBeConsideredEqual()
+        {
+            // Arrange
+            Hmac a = Hmac.ComputeSha2Hmac256("abc", "key");
+            Hmac b = Hmac.ComputeSha2Hmac256("abc", "key");
+
+            // Assert
+            Assert.Equal(a, b);
+        }
+
+        [Fact(DisplayName = "Different HMACs should not be considered equal (different data)")]
+        public void DifferentHashesShouldNotBeConsideredEqualWithDifferentData()
+        {
+            // Arrange
+            Hmac a = Hmac.ComputeSha2Hmac256("abc", "key");
+            Hmac b = Hmac.ComputeSha2Hmac256("xyz", "key");
+
+            // Assert
+            Assert.NotEqual(a, b);
+        }
+
+        [Fact(DisplayName = "Different HMACs should not be considered equal (different keys)")]
+        public void DifferentHashesShouldNotBeConsideredEqualWithDifferentKeys()
+        {
+            // Arrange
+            Hmac a = Hmac.ComputeSha2Hmac256("abc", "key");
+            Hmac b = Hmac.ComputeSha2Hmac256("abc", "123");
+
+            // Assert
+            Assert.NotEqual(a, b);
+        }
+
+        [Fact(DisplayName = "Parse should be able to parse a known hash")]
+        public void ParseShouldBeAbleToParseAKnownHash()
+        {
+            // Arrange
+            const string expected =
+                "Sha2Hmac256:73ac6fa8599f4bde8dfee594c7f5f6ff03023b2d99ca71a7eccf729a8fc5c324:48656c6c6f2c20576f726c6421";
+
+            // Act
+            Hmac hash = Hmac.Parse(expected);
+            string actual = hash.ToStringWithAlgorithmType();
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+    }
+}

OnixLabs.Security.Cryptography/HashAlgorithmType.Enumerations.cs

@@ -82,26 +82,26 @@ public sealed partial class HashAlgorithmType
         /// <summary>
         /// The MD5 HMAC keyed hash algorithm.
         /// </summary>
-        public static readonly HashAlgorithmType Md5HmacHash = new(12, nameof(Md5HmacHash), 16, true);
+        public static readonly HashAlgorithmType Md5Hmac = new(12, nameof(Md5Hmac), 16, true);
 
         /// <summary>
         /// The SHA-1 HMAC keyed hash algorithm.
         /// </summary>
-        public static readonly HashAlgorithmType Sha1HmacHash = new(13, nameof(Sha1HmacHash), 20, true);
+        public static readonly HashAlgorithmType Sha1Hmac = new(13, nameof(Sha1Hmac), 20, true);
 
         /// <summary>
         /// The SHA-2 256-bit HMAC keyed hash algorithm.
         /// </summary>
-        public static readonly HashAlgorithmType Sha2HmacHash256 = new(14, nameof(Sha2HmacHash256), 32, true);
+        public static readonly HashAlgorithmType Sha2Hmac256 = new(14, nameof(Sha2Hmac256), 32, true);
 
         /// <summary>
         /// The SHA-2 384-bit HMAC keyed hash algorithm.
         /// </summary>
-        public static readonly HashAlgorithmType Sha2HmacHash384 = new(15, nameof(Sha2HmacHash384), 48, true);
+        public static readonly HashAlgorithmType Sha2Hmac384 = new(15, nameof(Sha2Hmac384), 48, true);
 
         /// <summary>
         /// The SHA-2 512-bit HMAC keyed hash algorithm.
         /// </summary>
-        public static readonly HashAlgorithmType Sha2HmacHash512 = new(16, nameof(Sha2HmacHash512), 64, true);
+        public static readonly HashAlgorithmType Sha2Hmac512 = new(16, nameof(Sha2Hmac512), 64, true);
     }
 }

OnixLabs.Security.Cryptography/HashAlgorithmType.Get.cs

@@ -61,13 +61,18 @@ public HashAlgorithm GetHashAlgorithm(int length = UnknownLength)
         /// <exception cref="ArgumentException">If the hash algorithm is unknown.</exception>
         public KeyedHashAlgorithm GetKeyedHashAlgorithm(byte[]? key = null)
         {
+            if (!Keyed)
+            {
+                throw new ArgumentException($"Hash algorithm type '{Name}' is not a keyed hash algorithm.");
+            }
+
             return Name switch
             {
-                nameof(Md5HmacHash) => key is null ? new HMACMD5() : new HMACMD5(key),
-                nameof(Sha1HmacHash) => key is null ? new HMACSHA1() : new HMACSHA1(key),
-                nameof(Sha2HmacHash256) => key is null ? new HMACSHA256() : new HMACSHA256(key),
-                nameof(Sha2HmacHash384) => key is null ? new HMACSHA384() : new HMACSHA384(key),
-                nameof(Sha2HmacHash512) => key is null ? new HMACSHA512() : new HMACSHA512(key),
+                nameof(Md5Hmac) => key is null ? new HMACMD5() : new HMACMD5(key),
+                nameof(Sha1Hmac) => key is null ? new HMACSHA1() : new HMACSHA1(key),
+                nameof(Sha2Hmac256) => key is null ? new HMACSHA256() : new HMACSHA256(key),
+                nameof(Sha2Hmac384) => key is null ? new HMACSHA384() : new HMACSHA384(key),
+                nameof(Sha2Hmac512) => key is null ? new HMACSHA512() : new HMACSHA512(key),
                 _ => throw new ArgumentException($"Hash algorithm '{Name}' is unknown.")
             };
         }

OnixLabs.Security.Cryptography/Hmac.Compute.Md5Hmac.cs

@@ -0,0 +1,62 @@
+// Copyright 2020-2021 ONIXLabs
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//    http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Text;
+
+namespace OnixLabs.Security.Cryptography
+{
+    /// <summary>
+    /// Represents a hashed message authentication code (HMAC).
+    /// </summary>
+    public readonly partial struct Hmac
+    {
+        /// <summary>
+        /// Computes an MD5 HMAC from the specified value and key.
+        /// This will use the default encoding to convert the input value and key into a byte array.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeMd5Hmac(string value, string key)
+        {
+            return ComputeMd5Hmac(value, key, Encoding.Default);
+        }
+
+        /// <summary>
+        /// Computes an MD5 HMAC from the specified value and key.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <param name="encoding">The encoding which will be used to convert the value and key into a byte array.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeMd5Hmac(string value, string key, Encoding encoding)
+        {
+            byte[] valueBytes = encoding.GetBytes(value);
+            byte[] keyBytes = encoding.GetBytes(key);
+
+            return ComputeMd5Hmac(valueBytes, keyBytes);
+        }
+
+        /// <summary>
+        /// Computes an MD5 HMAC from the specified value and key.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeMd5Hmac(byte[] value, byte[] key)
+        {
+            return ComputeHmac(value, key, HashAlgorithmType.Md5Hmac);
+        }
+    }
+}

OnixLabs.Security.Cryptography/Hmac.Compute.Sha1Hmac.cs

@@ -0,0 +1,62 @@
+// Copyright 2020-2021 ONIXLabs
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//    http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Text;
+
+namespace OnixLabs.Security.Cryptography
+{
+    /// <summary>
+    /// Represents a hashed message authentication code (HMAC).
+    /// </summary>
+    public readonly partial struct Hmac
+    {
+        /// <summary>
+        /// Computes a SHA-1 HMAC from the specified value and key.
+        /// This will use the default encoding to convert the input value and key into a byte array.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeSha1Hmac(string value, string key)
+        {
+            return ComputeSha1Hmac(value, key, Encoding.Default);
+        }
+
+        /// <summary>
+        /// Computes a SHA-1 HMAC from the specified value and key.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <param name="encoding">The encoding which will be used to convert the value and key into a byte array.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeSha1Hmac(string value, string key, Encoding encoding)
+        {
+            byte[] valueBytes = encoding.GetBytes(value);
+            byte[] keyBytes = encoding.GetBytes(key);
+
+            return ComputeSha1Hmac(valueBytes, keyBytes);
+        }
+
+        /// <summary>
+        /// Computes a SHA-1 HMAC from the specified value and key.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeSha1Hmac(byte[] value, byte[] key)
+        {
+            return ComputeHmac(value, key, HashAlgorithmType.Sha1Hmac);
+        }
+    }
+}

OnixLabs.Security.Cryptography/Hmac.Compute.Sha2Hmac256.cs

@@ -0,0 +1,62 @@
+// Copyright 2020-2021 ONIXLabs
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//    http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Text;
+
+namespace OnixLabs.Security.Cryptography
+{
+    /// <summary>
+    /// Represents a hashed message authentication code (HMAC).
+    /// </summary>
+    public readonly partial struct Hmac
+    {
+        /// <summary>
+        /// Computes a SHA-2 256-bit HMAC from the specified value and key.
+        /// This will use the default encoding to convert the input value and key into a byte array.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeSha2Hmac256(string value, string key)
+        {
+            return ComputeSha2Hmac256(value, key, Encoding.Default);
+        }
+
+        /// <summary>
+        /// Computes a SHA-2 256-bit HMAC from the specified value and key.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <param name="encoding">The encoding which will be used to convert the value and key into a byte array.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeSha2Hmac256(string value, string key, Encoding encoding)
+        {
+            byte[] valueBytes = encoding.GetBytes(value);
+            byte[] keyBytes = encoding.GetBytes(key);
+
+            return ComputeSha2Hmac256(valueBytes, keyBytes);
+        }
+
+        /// <summary>
+        /// Computes a SHA-2 256-bit HMAC from the specified value and key.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeSha2Hmac256(byte[] value, byte[] key)
+        {
+            return ComputeHmac(value, key, HashAlgorithmType.Sha2Hmac256);
+        }
+    }
+}

OnixLabs.Security.Cryptography/Hmac.Compute.Sha2Hmac384.cs

@@ -0,0 +1,62 @@
+// Copyright 2020-2021 ONIXLabs
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//    http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Text;
+
+namespace OnixLabs.Security.Cryptography
+{
+    /// <summary>
+    /// Represents a hashed message authentication code (HMAC).
+    /// </summary>
+    public readonly partial struct Hmac
+    {
+        /// <summary>
+        /// Computes a SHA-2 384-bit HMAC from the specified value and key.
+        /// This will use the default encoding to convert the input value and key into a byte array.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeSha2Hmac384(string value, string key)
+        {
+            return ComputeSha2Hmac384(value, key, Encoding.Default);
+        }
+
+        /// <summary>
+        /// Computes a SHA-2 384-bit HMAC from the specified value and key.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <param name="encoding">The encoding which will be used to convert the value and key into a byte array.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeSha2Hmac384(string value, string key, Encoding encoding)
+        {
+            byte[] valueBytes = encoding.GetBytes(value);
+            byte[] keyBytes = encoding.GetBytes(key);
+
+            return ComputeSha2Hmac384(valueBytes, keyBytes);
+        }
+
+        /// <summary>
+        /// Computes a SHA-2 384-bit HMAC from the specified value and key.
+        /// </summary>
+        /// <param name="value">The value for which to compute a HMAC.</param>
+        /// <param name="key">The key for which to compute a HMAC.</param>
+        /// <returns>Returns a <see cref="Hmac"/> of the input value and key.</returns>
+        public static Hmac ComputeSha2Hmac384(byte[] value, byte[] key)
+        {
+            return ComputeHmac(value, key, HashAlgorithmType.Sha2Hmac384);
+        }
+    }
+}