Merge pull request #25 from johnkellyoxford/dev

Fixed and added overloads to HMAC

Author: john-h-k

CryptoTools/MessageAuthenticator.cs

@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using System.Linq;
 using System.Security.Cryptography;
 
@@ -7,7 +8,7 @@ namespace CryptoTools
     /// <summary>
     /// Used for signing and verifying HMACs
     /// </summary>
-    internal class MessageAuthenticator
+    public class MessageAuthenticator
     {
         /// <summary>
         /// Creates a byte[] hashcode that represents the file and key hashed with SHA384. Do not try and verify this yourself, use the VerifyHMAC() func
@@ -39,7 +40,7 @@ public byte[] CreateHMAC(byte[] data, byte[] key, Type typeOfHash)
             HMAC hmac;
             if (typeOfHash.IsSubclassOf(typeof(HMAC)))
             {
-                hmac = (HMAC)Activator.CreateInstance(typeOfHash);
+                hmac = (HMAC)Activator.CreateInstance(typeOfHash, key);
             }
             else
             {
@@ -56,6 +57,55 @@ public byte[] CreateHMAC(byte[] data, byte[] key, Type typeOfHash)
             return hashKey;
         }
 
+        /// <summary>
+        /// Creates a byte[] hashcode that represents the file and key hashed with SHA384. Do not try and verify this yourself, use the VerifyHMAC() func
+        /// </summary>
+        /// <param name="path">A path to the file with the encrypted data</param>
+        /// <param name="key">A byte[] of the key</param>
+        /// <returns>A byte[] hash that is the file and key hashed</returns>
+        public byte[] CreateHMAC(string path, byte[] key)
+        {
+            byte[] hashKey;
+
+            using (var fHandle = new FileStream(path, FileMode.Open))
+            using (var hmac = new HMACSHA384(key))
+            {
+                hashKey = hmac.ComputeHash(fHandle);
+            }
+
+            return hashKey;
+        }
+
+        /// <summary>
+        /// Signs a encrypted file and key with a hash algorithm of your choosing. Do not try and verify this yourself, use the VerifyHMAC() func
+        /// </summary>
+        /// <param name="path">A path to the file with the encrypted data</param>
+        /// <param name="key">A byte[] of the key</param>
+        /// <param name="typeOfHash">typeof() any derivative of the System.Security.Cryptography.HMAC class</param>
+        /// <returns>A byte[] hash that is the file and key hashed</returns>
+        public byte[] CreateHMAC(string path, byte[] key, Type typeOfHash)
+        {
+            HMAC hmac;
+            if (typeOfHash.IsSubclassOf(typeof(HMAC)))
+            {
+                hmac = (HMAC)Activator.CreateInstance(typeOfHash, key);
+            }
+            else
+            {
+                throw new ArgumentException("TypeOfHash is not a derivative of \"System.Security.Cryptography.HMAC\"");
+            }
+
+            byte[] hashKey;
+
+            using (var fHandle = new FileStream(path, FileMode.Open))
+            using (hmac)
+            {
+                hashKey = hmac.ComputeHash(fHandle);
+            }
+
+            return hashKey;
+        }
+
         /// <summary>
         /// A function that verifies a HMAC file with SHA384
         /// </summary>
@@ -72,7 +122,7 @@ public bool VerifyHMAC(byte[] data, byte[] key, byte[] hash)
                 hashKey = hmac.ComputeHash(data);
             }
 
-            return hashKey.SequenceEqual(hash);
+            return hash.SequenceEqual(hashKey);
         }
 
 
@@ -103,7 +153,59 @@ public bool VerifyHMAC(byte[] data, byte[] key, byte[] hash, Type typeOfHash)
                 hashKey = hmac.ComputeHash(data);
             }
 
-            return data.SequenceEqual(hashKey);  // returns true if they match
+            return hash.SequenceEqual(hashKey);  // returns true if they match
+        }
+
+        /// <summary>
+        /// A function that verifies a HMAC file with SHA384
+        /// </summary>
+        /// <param name="path">A path to the file with the encrypted data</param>
+        /// <param name="key">A byte[] of the key</param>
+        /// <param name="hash">The hash in the header file/the hash provided, that's been hashed with SHA384</param>
+        /// <returns>True if they match, otherwise false</returns>
+        public bool VerifyHMAC(string path, byte[] key, byte[] hash)
+        {
+            byte[] hashKey;
+
+            using (var fHandle = new FileStream(path, FileMode.Open))
+            using (var hmac = new HMACSHA384(key))
+            {
+                hashKey = hmac.ComputeHash(fHandle);
+            }
+
+            return hash.SequenceEqual(hashKey);
+        }
+
+
+        /// <summary>
+        /// A function that verifies a HMAC file with a hash algorithm of your choice
+        /// </summary>
+        /// <param name="path">A path to the file with the encrypted data</param>
+        /// <param name="key">A byte[] of the key</param>
+        /// <param name="hash">The hash in the header file/the hash provided, that's been hashed with typeOfHash</param>
+        /// <param name="typeOfHash">typeof() the hash algorithm you used to create this, derived from System.Security.Cryptography.HMAC</param>
+        /// <returns>True if they match, otherwise false</returns>
+        public bool VerifyHMAC(string path, byte[] key, byte[] hash, Type typeOfHash)
+        {
+            HMAC hmac;
+            if (typeOfHash.IsSubclassOf(typeof(HMAC)))
+            {
+                hmac = (HMAC)Activator.CreateInstance(typeOfHash, key);
+            }
+            else
+            {
+                throw new ArgumentException("TypeOfHash is not a derivative of \"System.Security.Cryptography.HMAC\"");
+            }
+
+            byte[] hashKey;
+
+            using (var fHandle = new FileStream(path, FileMode.Open))
+            using (hmac)
+            {
+                hashKey = hmac.ComputeHash(fHandle);
+            }
+
+            return hash.SequenceEqual(hashKey);  // returns true if they match
         }
     }
 }