Ejemplo n.º 1
0
        public void ComputeAndVerifyHash_File()
        {
            var testFilePath = Path.GetTempFileName();
            GenericHashResult verifyResult = new GenericHashResult();
            var errorMessage = "";

            File.WriteAllText(testFilePath, _testString);

            var hashResult = _md5.ComputeFileHash(testFilePath);

            if (hashResult.Success)
            {
                verifyResult = _md5.VerifyFileHash(hashResult.HashString, testFilePath);

                if (!verifyResult.Success)
                {
                    errorMessage = verifyResult.Message;
                }
            }
            else
            {
                errorMessage = hashResult.Message;
            }

            Assert.IsTrue((hashResult.Success && verifyResult.Success), errorMessage);
        }
Ejemplo n.º 2
0
        public GenericHashResult HashFile(string sourceFilePath, bool verbose = false)
        {
            if (!File.Exists(sourceFilePath))
            {
                return(new GenericHashResult()
                {
                    Success = false,
                    Message = $"File \"{sourceFilePath}\" not found."
                });
            }

            StringBuilder     sb     = null;
            GenericHashResult result = null;

            try
            {
                using (var md5 = System.Security.Cryptography.MD5.Create())
                {
                    using (var fs = File.OpenRead(sourceFilePath))
                    {
                        sb = new StringBuilder();
                        var hashedBytes = md5.ComputeHash(fs);

                        for (int i = 0; i < hashedBytes.Length; i++)
                        {
                            sb.Append(hashedBytes[i].ToString("X2"));
                        }

                        result = new GenericHashResult()
                        {
                            Success = true,
                            Message = $"File \"{sourceFilePath}\" succesfully hashed.",
                            Hash    = sb.ToString()
                        };
                    }
                }
            }
            catch (Exception ex)
            {
                return(new GenericHashResult()
                {
                    Success = false,
                    Message = ex.ToString()
                });
            }
            finally
            {
                sb.Clear();
                sb = null;
            }

            return(result);
        }
Ejemplo n.º 3
0
        public GenericHashResult HashString(string stringToBeHashed)
        {
            if (string.IsNullOrWhiteSpace(stringToBeHashed))
            {
                return(new GenericHashResult()
                {
                    Success = false,
                    Message = "String to be hashed required."
                });
            }

            StringBuilder     sb     = null;
            GenericHashResult result = null;

            try
            {
                using (var md5 = System.Security.Cryptography.MD5.Create())
                {
                    byte[] stringToBeHashedBytes = Encoding.UTF8.GetBytes(stringToBeHashed);
                    byte[] hashedBytes           = md5.ComputeHash(stringToBeHashedBytes);


                    sb = new StringBuilder();

                    for (int i = 0; i < hashedBytes.Length; i++)
                    {
                        sb.Append(hashedBytes[i].ToString("X2"));
                    }

                    result = new GenericHashResult()
                    {
                        Success = true,
                        Message = "String succesfully hashed.",
                        Hash    = sb.ToString()
                    };
                }
            }
            catch (Exception ex)
            {
                return(new GenericHashResult()
                {
                    Success = false,
                    Message = ex.ToString()
                });
            }
            finally
            {
                sb.Clear();
                sb = null;
            }

            return(result);
        }
Ejemplo n.º 4
0
        internal GenericHashResult ComputeHash(Enums.HashAlgorithm hashAlgorithm, byte[] bytesToComputeHash,
                                               int offset = 0, int count = 0)
        {
            if (bytesToComputeHash == null || bytesToComputeHash.Length <= 0)
            {
                return(new GenericHashResult()
                {
                    Success = false,
                    Message = MessageDictionary.Instance["Hash.InputRequired"]
                });
            }

            GenericHashResult result = null;

            try
            {
                using (var hashAlg = (HashAlgorithm)CryptoConfig.CreateFromName(hashAlgorithm.ToString()))
                {
                    //offset = (offset == 0 ? 0 : offset);
                    count = (count == 0 ? bytesToComputeHash.Length : count);

                    byte[] hash = hashAlg.ComputeHash(bytesToComputeHash, offset, count);

                    result = new GenericHashResult()
                    {
                        Success    = true,
                        Message    = MessageDictionary.Instance["Hash.ComputeSuccess"],
                        HashBytes  = hash,
                        HashString = Encoding.Hexadecimal.ToHexString(hash)
                    };
                }
            }
            catch (Exception ex)
            {
                return(new GenericHashResult()
                {
                    Success = false,
                    Message = ex.ToString()
                });
            }

            return(result);
        }
Ejemplo n.º 5
0
        public void ComputeAndVerifyHash_String()
        {
            var verifyResult = new GenericHashResult();
            var errorMessage = "";

            var hashResult = _sha384.ComputeHash(_testString);

            if (hashResult.Success)
            {
                verifyResult = _sha384.VerifyHash(hashResult.HashString, _testString);

                if (!verifyResult.Success)
                {
                    errorMessage = verifyResult.Message;
                }
            }
            else
            {
                errorMessage = hashResult.Message;
            }

            Assert.IsTrue((hashResult.Success && verifyResult.Success), errorMessage);
        }
Ejemplo n.º 6
0
        private static ExitCode RunHashOptionsAndReturnExitCode(HashOptions hashOptions)
        {
            GenericHashResult hashResult = null;

            switch (hashOptions.InputType.ToLower())
            {
            case "string":
            {
                hashResult = (hashOptions.Algorithm.ToLower()) switch
                {
                    "md5" => new MD5().ComputeHash(hashOptions.InputToComputeHash),
                    "sha1" => new SHA1().ComputeHash(hashOptions.InputToComputeHash),
                    "sha256" => new SHA256().ComputeHash(hashOptions.InputToComputeHash),
                    "sha384" => new SHA384().ComputeHash(hashOptions.InputToComputeHash),
                    "sha512" => new SHA512().ComputeHash(hashOptions.InputToComputeHash),
                    "pbkdf2" => new PBKDF2_HMAC_SHA_1().ComputeHash(hashOptions.InputToComputeHash),
                    "bcrypt" => new Hash.BCrypt().ComputeHash(hashOptions.InputToComputeHash),
                    _ => new GenericHashResult()
                    {
                        Success = false, Message = $"Unknown algorithm \"{hashOptions.Algorithm}\"."
                    },
                };
            }
            break;

            case "file":
            {
                switch (hashOptions.Algorithm.ToLower())
                {
                case "md5":
                {
                    using (var progressBar = new ProgressBar())
                    {
                        var md5 = new MD5();
                        md5.OnHashProgress += (percentageDone, message) => { progressBar.Report((double)percentageDone / 100); };
                        hashResult          = md5.ComputeFileHash(hashOptions.InputToComputeHash);
                    }
                }
                break;

                case "sha1":
                {
                    using (var progressBar = new ProgressBar())
                    {
                        var sha1 = new SHA1();
                        sha1.OnHashProgress += (percentageDone, message) => { progressBar.Report((double)percentageDone / 100); };
                        hashResult           = sha1.ComputeFileHash(hashOptions.InputToComputeHash);
                    }
                }
                break;

                case "sha256":
                {
                    using (var progressBar = new ProgressBar())
                    {
                        var sha256 = new SHA256();
                        sha256.OnHashProgress += (percentageDone, message) => { progressBar.Report((double)percentageDone / 100); };
                        hashResult             = sha256.ComputeFileHash(hashOptions.InputToComputeHash);
                    }
                }
                break;

                case "sha384":
                {
                    using (var progressBar = new ProgressBar())
                    {
                        var sha384 = new SHA384();
                        sha384.OnHashProgress += (percentageDone, message) => { progressBar.Report((double)percentageDone / 100); };
                        hashResult             = sha384.ComputeFileHash(hashOptions.InputToComputeHash);
                    }
                }
                break;

                case "sha512":
                {
                    using (var progressBar = new ProgressBar())
                    {
                        var sha512 = new SHA512();
                        sha512.OnHashProgress += (percentageDone, message) => { progressBar.Report((double)percentageDone / 100); };
                        hashResult             = sha512.ComputeFileHash(hashOptions.InputToComputeHash);
                    }
                }
                break;

                case "pbkdf2":
                case "bcrypt":
                    hashResult = new GenericHashResult()
                    {
                        Success = false, Message = $"Algorithm \"{hashOptions.Algorithm}\" currently not available for file hashing."
                    };
                    break;

                default:
                    hashResult = new GenericHashResult()
                    {
                        Success = false, Message = $"Unknown algorithm \"{hashOptions.Algorithm}\"."
                    };
                    break;
                }
            }
            break;

            default:
                hashResult = new GenericHashResult()
                {
                    Success = false, Message = $"Unknown input type \"{hashOptions.InputType}\"."
                };
                break;
            }

            if (hashResult.Success && !string.IsNullOrWhiteSpace(hashOptions.CompareHash))
            {
                var hashesMatch = (
                    hashOptions.Algorithm.ToLower() != "bcrypt" && hashOptions.Algorithm.ToLower() != "pbkdf2"
                        ? (hashResult.HashString).Equals(hashOptions.CompareHash, StringComparison.InvariantCultureIgnoreCase)
                        : (hashOptions.Algorithm.ToLower() == "bcrypt"
                            ? new Hash.BCrypt().VerifyHash(hashOptions.InputToComputeHash, hashOptions.CompareHash).Success
                            : new Hash.PBKDF2_HMAC_SHA_1().VerifyHash(hashOptions.InputToComputeHash, hashOptions.CompareHash).Success
                           )
                    );
                var outputMessage = (
                    hashesMatch
                        ? $"Computed hash MATCH with given hash: {(hashOptions.Algorithm.ToLower() != "bcrypt" ? hashResult.HashString : hashOptions.CompareHash)}"
                        : $"Computed hash DOES NOT MATCH with given hash." +
                    (
                        hashOptions.Algorithm.ToLower() != "bcrypt"
                                ? $"\nComputed hash: {hashResult.HashString}\nGiven hash: {hashOptions.CompareHash}"
                                : ""
                    )
                    );
                Console.WriteLine(outputMessage);

                return(hashesMatch ? ExitCode.Sucess : ExitCode.Error);
            }
            else if (hashResult.Success && string.IsNullOrWhiteSpace(hashOptions.CompareHash))
            {
                Console.WriteLine(hashResult.HashString);

                return(ExitCode.Sucess);
            }
            else
            {
                Console.WriteLine(hashResult.Message);

                return(ExitCode.Error);
            }
        }
Ejemplo n.º 7
0
        internal GenericHashResult ComputeFileHash(Enums.HashAlgorithm hashAlgorithm, string filePathToComputeHash,
                                                   long offset = 0, long count = 0)
        {
            if (!File.Exists(filePathToComputeHash))
            {
                return(new GenericHashResult()
                {
                    Success = false,
                    Message = $"{MessageDictionary.Instance["Common.FileNotFound"]} \"{filePathToComputeHash}\"."
                });
            }

            GenericHashResult result = null;

            try
            {
                byte[] hash = null;

                using (var fStream = new FileStream(filePathToComputeHash, FileMode.Open, FileAccess.Read, FileShare.None))
                {
                    //offset = (offset == 0 ? 0 : offset);
                    count            = (count == 0 ? fStream.Length : count);
                    fStream.Position = offset;
                    byte[] buffer = new byte[(1024 * 4)];
                    long   amount = (count - offset);

                    using (var hashAlg = (HashAlgorithm)CryptoConfig.CreateFromName(hashAlgorithm.ToString()))
                    {
                        int percentageDone = 0;

                        while (amount > 0)
                        {
                            int bytesRead = fStream.Read(buffer, 0, (int)Math.Min(buffer.Length, amount));

                            if (bytesRead > 0)
                            {
                                amount -= bytesRead;

                                if (amount > 0)
                                {
                                    hashAlg.TransformBlock(buffer, 0, bytesRead, buffer, 0);
                                }
                                else
                                {
                                    hashAlg.TransformFinalBlock(buffer, 0, bytesRead);
                                }

                                var tmpPercentageDone = (int)(fStream.Position * 100 / count);

                                if (tmpPercentageDone != percentageDone)
                                {
                                    percentageDone = tmpPercentageDone;

                                    RaiseOnHashProgress(percentageDone, (percentageDone != 100 ? $"Computing hash ({percentageDone}%)..." : $"Hash computed ({percentageDone}%)."));
                                }
                            }
                            else
                            {
                                throw new InvalidOperationException();
                            }
                        }

                        hash = hashAlg.Hash;
                    }
                }

                result = new GenericHashResult()
                {
                    Success    = true,
                    Message    = MessageDictionary.Instance["Hash.ComputeSuccess"],
                    HashString = Encoding.Hexadecimal.ToHexString(hash),
                    HashBytes  = hash
                };
            }
            catch (Exception ex)
            {
                result = new GenericHashResult()
                {
                    Success = false,
                    Message = ex.ToString()
                };
            }

            return(result);
        }
Ejemplo n.º 8
0
        private static ExitCode RunHashOptionsAndReturnExitCode(HashOptions hashOptions)
        {
            GenericHashResult hashResult = null;

            switch (hashOptions.InputType.ToLower())
            {
            case "string":
            {
                switch (hashOptions.Algorithm.ToLower())
                {
                case "md5":
                    hashResult = new MD5().HashString(hashOptions.InputToBeHashed);
                    break;

                case "sha1":
                    hashResult = new SHA1().HashString(hashOptions.InputToBeHashed);
                    break;

                case "sha256":
                    hashResult = new SHA256().HashString(hashOptions.InputToBeHashed);
                    break;

                case "sha384":
                    hashResult = new SHA384().HashString(hashOptions.InputToBeHashed);
                    break;

                case "sha512":
                    hashResult = new SHA512().HashString(hashOptions.InputToBeHashed);
                    break;

                case "bcrypt":
                    hashResult = new Hash.BCrypt().HashString(hashOptions.InputToBeHashed);
                    break;

                default:
                    hashResult = new GenericHashResult()
                    {
                        Success = false, Message = $"Unknown algorithm \"{hashOptions.Algorithm}\"."
                    };
                    break;
                }
            }
            break;

            case "file":
            {
                switch (hashOptions.Algorithm.ToLower())
                {
                case "md5":
                    hashResult = new MD5().HashFile(hashOptions.InputToBeHashed, hashOptions.Verbose);
                    break;

                case "sha1":
                    hashResult = new SHA1().HashFile(hashOptions.InputToBeHashed, hashOptions.Verbose);
                    break;

                case "sha256":
                    hashResult = new SHA256().HashFile(hashOptions.InputToBeHashed, hashOptions.Verbose);
                    break;

                case "sha384":
                    hashResult = new SHA384().HashFile(hashOptions.InputToBeHashed, hashOptions.Verbose);
                    break;

                case "sha512":
                    hashResult = new SHA512().HashFile(hashOptions.InputToBeHashed, hashOptions.Verbose);
                    break;

                case "bcrypt":
                    hashResult = new GenericHashResult()
                    {
                        Success = false, Message = $"Algorithm \"{hashOptions.Algorithm}\" currently not available for file hashing."
                    };
                    break;

                default:
                    hashResult = new GenericHashResult()
                    {
                        Success = false, Message = $"Unknown algorithm \"{hashOptions.Algorithm}\"."
                    };
                    break;
                }
            }
            break;

            default:
                hashResult = new GenericHashResult()
                {
                    Success = false, Message = $"Unknown input type \"{hashOptions.InputType}\"."
                };
                break;
            }

            if (hashResult.Success && !string.IsNullOrWhiteSpace(hashOptions.CompareHash))
            {
                bool hashesMatch = (
                    hashOptions.Algorithm.ToLower() != "bcrypt"
                        ? (hashResult.Hash).Equals(hashOptions.CompareHash, StringComparison.InvariantCultureIgnoreCase)
                        : new Hash.BCrypt().Verify(hashOptions.InputToBeHashed, hashOptions.CompareHash).Success
                    );

                var outputMessage = (
                    hashesMatch
                        ? $"Computed hash MATCH with given hash: {(hashOptions.Algorithm.ToLower() != "bcrypt" ? hashResult.Hash : hashOptions.CompareHash)}"
                        : $"Computed hash DOES NOT MATCH with given hash." +
                    (
                        hashOptions.Algorithm.ToLower() != "bcrypt"
                                ? $"\nComputed hash: {hashResult.Hash}\nGiven hash: {hashOptions.CompareHash}"
                                : ""
                    )
                    );

                Console.WriteLine(outputMessage);

                return(hashesMatch ? ExitCode.Sucess : ExitCode.Error);
            }
            else if (hashResult.Success && string.IsNullOrWhiteSpace(hashOptions.CompareHash))
            {
                Console.WriteLine(hashResult.Hash);

                return(ExitCode.Sucess);
            }
            else
            {
                Console.WriteLine(hashResult.Message);

                return(ExitCode.Error);
            }
        }
Ejemplo n.º 9
0
        internal GenericHashResult ComputeHash(Enums.HashAlgorithm hashAlgorithm, byte[] bytesToComputeHash,
                                               int offset = 0, int count = 0)
        {
            if (bytesToComputeHash == null || bytesToComputeHash.Length <= 0)
            {
                return(new GenericHashResult()
                {
                    Success = false,
                    Message = MessageDictionary.Instance["Hash.InputRequired"]
                });
            }

            GenericHashResult result = null;

            try
            {
                HashAlgorithm hashAlg = null;

#if CORERT
                switch (hashAlgorithm)
                {
                case Enums.HashAlgorithm.MD5:
                    hashAlg = MD5.Create();
                    break;

                case Enums.HashAlgorithm.SHA1:
                    hashAlg = SHA1.Create();
                    break;

                case Enums.HashAlgorithm.SHA256:
                    hashAlg = SHA256.Create();
                    break;

                case Enums.HashAlgorithm.SHA384:
                    hashAlg = SHA384.Create();
                    break;

                case Enums.HashAlgorithm.SHA512:
                    hashAlg = SHA512.Create();
                    break;

                case Enums.HashAlgorithm.BCrypt:
                default:
                    break;
                }
#else
                hashAlg = (HashAlgorithm)CryptoConfig.CreateFromName(hashAlgorithm.ToString());
#endif

                using (hashAlg)
                {
                    //offset = (offset == 0 ? 0 : offset);
                    count = (count == 0 ? bytesToComputeHash.Length : count);

                    byte[] hash = hashAlg.ComputeHash(bytesToComputeHash, offset, count);

                    result = new GenericHashResult()
                    {
                        Success    = true,
                        Message    = MessageDictionary.Instance["Hash.ComputeSuccess"],
                        HashBytes  = hash,
                        HashString = Encoding.HighPerformanceHexadecimal.ToHexString(hash)
                    };
                }
            }
            catch (Exception ex)
            {
                return(new GenericHashResult()
                {
                    Success = false,
                    Message = ex.ToString()
                });
            }

            return(result);
        }
Ejemplo n.º 10
0
        internal GenericHashResult ComputeFileHash(Enums.HashAlgorithm hashAlgorithm, string filePathToComputeHash,
                                                   long offset = 0, long count = 0)
        {
            if (!File.Exists(filePathToComputeHash))
            {
                return(new GenericHashResult()
                {
                    Success = false,
                    Message = $"{MessageStrings.Common_FileNotFound} \"{filePathToComputeHash}\"."
                });
            }

            GenericHashResult result  = null;
            HashAlgorithm     hashAlg = null;

#if CORERT
            switch (hashAlgorithm)
            {
            case Enums.HashAlgorithm.MD5:
                hashAlg = MD5.Create();
                break;

            case Enums.HashAlgorithm.SHA1:
                hashAlg = SHA1.Create();
                break;

            case Enums.HashAlgorithm.SHA256:
                hashAlg = SHA256.Create();
                break;

            case Enums.HashAlgorithm.SHA384:
                hashAlg = SHA384.Create();
                break;

            case Enums.HashAlgorithm.SHA512:
                hashAlg = SHA512.Create();
                break;

            case Enums.HashAlgorithm.BCrypt:
            default:
                break;
            }
#else
            hashAlg = (HashAlgorithm)CryptoConfig.CreateFromName(hashAlgorithm.ToString());
#endif

            try
            {
                byte[] hash = null;

                using (var fStream = new FileStream(filePathToComputeHash, FileMode.Open, FileAccess.Read, FileShare.None))
                {
                    //offset = (offset == 0 ? 0 : offset);
                    count            = (count == 0 ? fStream.Length : count);
                    fStream.Position = offset;
                    var buffer = new byte[(1024 * 4)];
                    var amount = (count - offset);

                    using (hashAlg)
                    {
                        var percentageDone = 0;

                        while (amount > 0)
                        {
                            var bytesRead = fStream.Read(buffer, 0, (int)Math.Min(buffer.Length, amount));

                            if (bytesRead > 0)
                            {
                                amount -= bytesRead;

                                if (amount > 0)
                                {
                                    hashAlg.TransformBlock(buffer, 0, bytesRead, buffer, 0);
                                }
                                else
                                {
                                    hashAlg.TransformFinalBlock(buffer, 0, bytesRead);
                                }

                                var tmpPercentageDone = (int)(fStream.Position * 100 / count);

                                if (tmpPercentageDone != percentageDone)
                                {
                                    percentageDone = tmpPercentageDone;

                                    RaiseOnHashProgress(percentageDone, (percentageDone != 100 ? $"Computing hash ({percentageDone}%)..." : $"Hash computed ({percentageDone}%)."));
                                }
                            }
                            else
                            {
                                throw new InvalidOperationException();
                            }
                        }

                        hash = hashAlg.Hash;
                    }
                }

                result = new GenericHashResult()
                {
                    Success    = true,
                    Message    = MessageStrings.Hash_ComputeSuccess,
                    HashString = Encoding.HighPerformanceHexadecimal.ToHexString(hash),
                    HashBytes  = hash
                };
            }
            catch (Exception ex)
            {
                result = new GenericHashResult()
                {
                    Success = false,
                    Message = ex.ToString()
                };
            }

            return(result);
        }