Laden...

Hash Codes aus Text oder Filestreams errechnen

Erstellt von schoko01 vor 14 Jahren Letzter Beitrag vor 13 Jahren 8.104 Views
S
schoko01 Themenstarter:in
23 Beiträge seit 2006
vor 14 Jahren
Hash Codes aus Text oder Filestreams errechnen

Kleine Klasse die Hash codes von String oder Files errechnet

<Die Klasse errechnet Hash codes der verschiedenen HashTypen MD5, SHA1,SHA256 und SHA512 aus String oder Filestream.
Habe dafür verschiedene CodeSnippets vereint und erweitert.>


using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Security.Cryptography;



namespace Hasher
{
    public class Hash
    {
        public Hash() { }
        
        public enum HashType : int
        {
            MD5,
            SHA1,
            SHA256,
            SHA512
        }

        /// <summary>
        /// Berechnet die verschiedenen Hashcode-Typen eines Strings
        /// </summary>
        /// <param name="text">String Text aus dem der Hash errechnet werden soll</param>
        /// <param name="hashType">HashType - MD5,SHA1,SHA256 oder SHA512</param>
        /// <returns>string Hash</returns>
        public static string GetHashFromString(string text, HashType hashType)
        {
            string hashString;
            switch (hashType)
            {
                case HashType.MD5:
                    hashString = GetMD5(text);
                    break;
                case HashType.SHA1:
                    hashString = GetSHA1(text);
                    break;
                case HashType.SHA256:
                    hashString = GetSHA256(text);
                    break;
                case HashType.SHA512:
                    hashString = GetSHA512(text);
                    break;
                default:
                    hashString = "Invalid Hash Type";
                    break;
            }
            return hashString;
        }

        /// <summary>
        /// Berechnet die verschiedenen Hashcode-Typen eines Filestreams
        /// </summary>
        /// <param name="Filename">Vollständiger Pfad + Dateiname</param>
        /// <param name="hashType">HashType - MD5,SHA1,SHA256 oder SHA512</param>
        /// <returns>string Hash</returns>
        public static string GetHashFormFile(string Filename, HashType hashType)
        {
            string hashString;

            switch (hashType)
            {
                case HashType.MD5:
                    hashString = GetMD5(Filename,FileMode.Open, FileAccess.Read);
                    break;
                case HashType.SHA1:
                    hashString = GetSHA1(Filename, FileMode.Open, FileAccess.Read);
                    break;
                case HashType.SHA256:
                    hashString = GetSHA256(Filename, FileMode.Open, FileAccess.Read);
                    break;
                case HashType.SHA512:
                    hashString = GetSHA512(Filename, FileMode.Open, FileAccess.Read);
                    break;
                default:
                    hashString = "Invalid Hash Type";
                    break;
            }
            return hashString;
        }

        /// <summary>
        /// String Hash vergleichen
        /// </summary>
        /// <param name="original">Originalstring</param>
        /// <param name="hashString">Hashstring</param>
        /// <param name="hashType">HashType</param>
        /// <returns>bool Vergleich IO/NIO</returns>
        public static bool CheckStringHash(string original, string hashString, HashType hashType)
        {
            string originalHash = GetHashFromString(original, hashType);
            return (originalHash == hashString);
        }

        #region // Get MD5
        
        
        /// <summary>
        /// Get MD5 Funktion aus String text
        /// </summary>
        /// <param name="text">//String aus dem der Hash ermittelt werden soll</param>
        /// <returns>string Hashcode</returns>
        private static string GetMD5(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);

            MD5 hashString = new MD5CryptoServiceProvider();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        /// <summary>
        /// Get MD5 Hash von einer Datei
        /// </summary>
        /// <param name="Filename">Vollständiger Dateipfad</param>
        /// <param name="fmode">Filemode zum Öffner der Datei</param>
        /// <param name="faccess">Fileaccess - Zugriffsart auf die Datei
        /// READ
        /// READ/WRITE
        /// WRITE</param>
        /// <returns>string Hashcode</returns>
        private static string GetMD5(string Filename, FileMode fmode, FileAccess faccess)
        {
            FileStream fs = new FileStream(Filename, fmode, faccess);
            byte[] hashValue;
            
            MD5 hashString = new MD5CryptoServiceProvider();
            string hex = "";

            hashValue = hashString.ComputeHash(fs);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        #endregion 

        #region //Get SHA1
        /// <summary>
        /// Get SHA1 Funktion aus String text
        /// </summary>
        /// <param name="text">//String aus dem der Hash ermittelt werden soll</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA1(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);

            SHA1Managed hashString = new SHA1Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }

        /// <summary>
        /// Get SHA1 Hash von einer Datei
        /// </summary>
        /// <param name="Filename">Vollständiger Dateipfad</param>
        /// <param name="fmode">Filemode zum Öffner der Datei</param>
        /// <param name="faccess">Fileaccess - Zugriffsart auf die Datei
        /// READ
        /// READ/WRITE
        /// WRITE</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA1(string Filename, FileMode fmode, FileAccess faccess)
        {
            FileStream fs = new FileStream(Filename, fmode, faccess);
            byte[] hashValue;

            SHA1Managed hashString = new SHA1Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(fs);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        #endregion

        #region //Get SHA256
        /// <summary>
        /// Get SHA256 Funktion aus String text
        /// </summary>
        /// <param name="text">//String aus dem der Hash ermittelt werden soll</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA256(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);

            SHA256Managed hashString = new SHA256Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }

        /// <summary>
        /// Get SHA256 Hash von einer Datei
        /// </summary>
        /// <param name="Filename">Vollständiger Dateipfad</param>
        /// <param name="fmode">Filemode zum Öffner der Datei</param>
        /// <param name="faccess">Fileaccess - Zugriffsart auf die Datei
        /// READ
        /// READ/WRITE
        /// WRITE</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA256(string Filename, FileMode fmode, FileAccess faccess)
        {
            FileStream fs = new FileStream(Filename, fmode, faccess);
            byte[] hashValue;

            SHA256Managed hashString = new SHA256Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(fs);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        #endregion

        #region //Get SHA512
        /// <summary>
        /// Get SHA512 Funktion aus String text
        /// </summary>
        /// <param name="text">//String aus dem der Hash ermittelt werden soll</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA512(string text)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] hashValue;
            byte[] message = UE.GetBytes(text);

            SHA512Managed hashString = new SHA512Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }

        /// <summary>
        /// Get SHA512 Hash von einer Datei
        /// </summary>
        /// <param name="Filename">Vollständiger Dateipfad</param>
        /// <param name="fmode">Filemode zum Öffner der Datei</param>
        /// <param name="faccess">Fileaccess - Zugriffsart auf die Datei
        /// READ
        /// READ/WRITE
        /// WRITE</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA512(string Filename, FileMode fmode, FileAccess faccess)
        {
            FileStream fs = new FileStream(Filename, fmode, faccess);
            byte[] hashValue;

            SHA512Managed hashString = new SHA512Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(fs);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        #endregion
    }
}

Schlagwörter: <Hash, MD5, SHA1, SHA256, SHA512, String, File, Datei, Hash Code>

3.971 Beiträge seit 2006
vor 14 Jahren

Kleiner Hinweis, es gibt für Hash eine gemeinsame Basis-Klasse (HashAlgorithm-Klasse). Durch die Verwendung des Enums HashType schränkst du die Klasse Hash auf von dir festgelegte Hash-Algorithmen ein.

Um das Problem elegant zu lösen, schmeiß das Enum weg, erstelle eine öffentliche Property (read, write) mit der von mir oben genannten Klasse und ersetze alle Abfragen auf das Enum durch das Property.

Weiterhin hast du durch die Verwendung des Enums sehr viel Copy&Paste-Code. Mit der Abstrahierung auf eine gemeinsame Basis-Klasse (Hash-Algorithm-Klasse) kannst du den kompletten Code in einer kleinen Funktion unerbringen. Der Code wird dadurch kompakter und auch übersichtlicher. Zusätzlich kannst natürlich diverse Überladungen für Stream, TextReader, FileInfo, usw erstellen.

Weiterhin ist der Name "Hash" für deine Klasse in meinen Augen nicht gerade prickelnd. HashProvider oder HashHelper wäre für mich ein sprechenderer Name - ist aber geschmackssache.

Ansonsten find ich die Idee für solch einen Helper sehr gut 🙂

Es gibt 3 Arten von Menschen, die die bis 3 zählen können und die, die es nicht können...

4.931 Beiträge seit 2008
vor 14 Jahren

Und du hast noch einen kleinen Verdreher drin:


GetHashFormFile // sollte wohl GetHashFromFile heißen

5.299 Beiträge seit 2008
vor 14 Jahren

Hi!

thx for the snippet, ich hab gar nicht gewußt, wie (und wie einfach) man Hashcodes berechnet.
paar Vorschläge:
Die ServiceCryptoProvider in einen Using-Block tun
Als Encoding kein neues nehmen, sondern ein gegebenes, statisches, etwa System.Text.Enconding.Unicode
Den Hashcode entweder als Byte-Array belassen (ist wohl das kürzeste Format), oder zB. System.Convert.ToBase64String() die Konvertierung machen lassen. Das ist dann zwar kein Hex-String, aber lesen kanns eh keiner, und kürzer ist es außerdem.

Der frühe Apfel fängt den Wurm.

V
162 Beiträge seit 2010
vor 13 Jahren

Hi,

ich hab den Snipp hier mal erweitert und verbessert.
Da dies ein Helper für mich ist, habe ich die Abstracte HashAlgorithm-Klasse nicht implementiert.

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Security.Cryptography;

namespace Helper
{
 /// <summary>
    /// Hash helper für MD5, SHA1, SHA265, SHA384, SHA512
    /// </summary>
    public static class Hash
    {
        /// <summary>
        /// Hash type wie MD5 SHA1, SHA256, SHA384, SHA512
        /// </summary>
        public enum HashType : int
        {
            /// <summary>
            /// MD5 = 32 Char Hash
            /// </summary>
            MD5,
            /// <summary>
            /// SHA1 = 40 Char Hash
            /// </summary>
            SHA1,
            /// <summary>
            /// SHA256 = 64 Char Hash
            /// </summary>
            SHA256,
            /// <summary>
            /// SHA384 = 96 Char Hash
            /// </summary>
            SHA384,
            /// <summary>
            /// SHA512 = 128 Char Hash
            /// </summary>
            SHA512
        }

        /// <summary>
        /// Berechnet die verschiedenen Hashcode-Typen eines Strings
        /// </summary>
        /// <param name="text">String Text aus dem der Hash errechnet werden soll</param>
        /// <param name="hashType">HashType - MD5, SHA1, SHA256, SHA384 oder SHA512</param>
        /// <returns>string Hash</returns>
        public static string GetHashFromString(string text, HashType hashType)
        {
            string hashString;
            switch (hashType)
            {
                case HashType.MD5:
                    hashString = GetMD5(text);
                    break;
                case HashType.SHA1:
                    hashString = GetSHA1(text);
                    break;
                case HashType.SHA256:
                    hashString = GetSHA256(text);
                    break;
               case HashType.SHA384:
                    hashString = GetSHA384(text);
                    break;
                case HashType.SHA512:
                    hashString = GetSHA512(text);
                    break;
                default:
                    hashString = "Invalid Hash Type";
                    break;
            }
            return hashString;
        }

        /// <summary>
        /// Berechnet die verschiedenen Hashcode-Typen eines Filestreams
        /// </summary>
        /// <param name="Filename">Vollständiger Pfad + Dateiname</param>
        /// <param name="hashType">HashType - MD5,SHA1,SHA256,SHA384 oder SHA512</param>
        /// <returns>string Hash</returns>
        public static string GetHashFormFile(string Filename, HashType hashType)
        {
            string hashString;

            switch (hashType)
            {
                case HashType.MD5:
                    hashString = GetMD5(Filename, FileMode.Open, FileAccess.Read);
                    break;
                case HashType.SHA1:
                    hashString = GetSHA1(Filename, FileMode.Open, FileAccess.Read);
                    break;
                case HashType.SHA256:
                    hashString = GetSHA256(Filename, FileMode.Open, FileAccess.Read);
                    break;
                case HashType.SHA384:
                    hashString = GetSHA384(Filename, FileMode.Open, FileAccess.Read);
                    break;
                case HashType.SHA512:
                    hashString = GetSHA512(Filename, FileMode.Open, FileAccess.Read);
                    break;
                default:
                    hashString = "Invalid Hash Type";
                    break;
            }
            return hashString;
        }

        #region // Verify


        /// <summary>
        /// String String vergleichen
        /// </summary>
        /// <param name="originalString">Originalstring</param>
        /// <param name="verifyString">Verifystring</param>
        /// <param name="hashType">HashType</param>
        /// <returns>bool Vergleich IO/NIO</returns>
        public static bool verifyStringAndString(string originalString, string verifyString, HashType hashType)
        {
            string originalHash = GetHashFromString(originalString, hashType);
            string verifyHash = GetHashFromString(verifyString, hashType);
            return (verifyHashAndHash(originalHash, verifyHash));
        }
        /// <summary>
        /// String Hash vergleichen
        /// </summary>
        /// <param name="originalString">Originalstring</param>
        /// <param name="verifyHash">Verifyhash</param>
        /// <param name="hashType">HashType</param>
        /// <returns>bool Vergleich IO/NIO</returns>
        public static bool verifyStringHash(string originalString, string verifyHash, HashType hashType)
        {
            string originalHash = GetHashFromString(originalString, hashType);
            return (verifyHashAndHash(originalHash, verifyHash));
        }
        /// <summary>
        /// Hash Hash vergleichen
        /// </summary>
        /// <param name="originalHash">Originalhash</param>
        /// <param name="verifyHash">Verifyhash</param>
        /// <returns>bool Vergleich IO/NIO</returns>
        public static bool verifyHashAndHash(string originalHash, string verifyHash)
        {
            //OrdinalIgnoreCase = non case sensitive
            StringComparer strComparer = StringComparer.OrdinalIgnoreCase;
            if (0 == strComparer.Compare(originalHash, verifyHash))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        #endregion

        #region // Get MD5
        

        /// <summary>
        /// Get MD5 Funktion aus String text
        /// </summary>
        /// <param name="text">//String aus dem der Hash ermittelt werden soll</param>
        /// <returns>string Hashcode</returns>
        private static string GetMD5(string text)
        {
            byte[] hashValue;
            byte[] message = Encoding.Unicode.GetBytes(text);

            MD5 hashString = new MD5CryptoServiceProvider();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        /// <summary>
        /// Get MD5 Hash von einer Datei
        /// </summary>
        /// <param name="Filename">Vollständiger Dateipfad</param>
        /// <param name="fmode">Filemode zum Öffner der Datei</param>
        /// <param name="faccess">Fileaccess - Zugriffsart auf die Datei
        /// READ
        /// READ/WRITE
        /// WRITE</param>
        /// <returns>string Hashcode</returns>
        private static string GetMD5(string Filename, FileMode fmode, FileAccess faccess)
        {
            FileStream fs = new FileStream(Filename, fmode, faccess);
            byte[] hashValue;

            MD5 hashString = new MD5CryptoServiceProvider();
            string hex = "";

            hashValue = hashString.ComputeHash(fs);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        #endregion

        #region //Get SHA1
        /// <summary>
        /// Get SHA1 Funktion aus String text
        /// </summary>
        /// <param name="text">//String aus dem der Hash ermittelt werden soll</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA1(string text)
        {
            byte[] hashValue;
            byte[] message = Encoding.Unicode.GetBytes(text);

            SHA1Managed hashString = new SHA1Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }

        /// <summary>
        /// Get SHA1 Hash von einer Datei
        /// </summary>
        /// <param name="Filename">Vollständiger Dateipfad</param>
        /// <param name="fmode">Filemode zum Öffner der Datei</param>
        /// <param name="faccess">Fileaccess - Zugriffsart auf die Datei
        /// READ
        /// READ/WRITE
        /// WRITE</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA1(string Filename, FileMode fmode, FileAccess faccess)
        {
            FileStream fs = new FileStream(Filename, fmode, faccess);
            byte[] hashValue;

            SHA1Managed hashString = new SHA1Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(fs);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        #endregion

        #region //Get SHA256
        /// <summary>
        /// Get SHA256 Funktion aus String text
        /// </summary>
        /// <param name="text">//String aus dem der Hash ermittelt werden soll</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA256(string text)
        {
            byte[] hashValue;
            byte[] message = Encoding.Unicode.GetBytes(text);

            SHA256Managed hashString = new SHA256Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }

        /// <summary>
        /// Get SHA256 Hash von einer Datei
        /// </summary>
        /// <param name="Filename">Vollständiger Dateipfad</param>
        /// <param name="fmode">Filemode zum Öffner der Datei</param>
        /// <param name="faccess">Fileaccess - Zugriffsart auf die Datei
        /// READ
        /// READ/WRITE
        /// WRITE</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA256(string Filename, FileMode fmode, FileAccess faccess)
        {
            FileStream fs = new FileStream(Filename, fmode, faccess);
            byte[] hashValue;

            SHA256Managed hashString = new SHA256Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(fs);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        #endregion

        #region //Get SHA384
        /// <summary>
        /// Get SHA384 Funktion aus String text
        /// </summary>
        /// <param name="text">//String aus dem der Hash ermittelt werden soll</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA384(string text)
        {
            byte[] hashValue;
            byte[] message = Encoding.Unicode.GetBytes(text);

            SHA384Managed hashString = new SHA384Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }

        /// <summary>
        /// Get SHA384 Hash von einer Datei
        /// </summary>
        /// <param name="Filename">Vollständiger Dateipfad</param>
        /// <param name="fmode">Filemode zum Öffner der Datei</param>
        /// <param name="faccess">Fileaccess - Zugriffsart auf die Datei
        /// READ
        /// READ/WRITE
        /// WRITE</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA384(string Filename, FileMode fmode, FileAccess faccess)
        {
            FileStream fs = new FileStream(Filename, fmode, faccess);
            byte[] hashValue;
            
            SHA384Managed hashString = new SHA384Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(fs);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        #endregion

        #region //Get SHA512
        /// <summary>
        /// Get SHA512 Funktion aus String text
        /// </summary>
        /// <param name="text">//String aus dem der Hash ermittelt werden soll</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA512(string text)
        {
            byte[] hashValue;
            byte[] message = Encoding.Unicode.GetBytes(text);

            SHA512Managed hashString = new SHA512Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(message);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }

        /// <summary>
        /// Get SHA512 Hash von einer Datei
        /// </summary>
        /// <param name="Filename">Vollständiger Dateipfad</param>
        /// <param name="fmode">Filemode zum Öffner der Datei</param>
        /// <param name="faccess">Fileaccess - Zugriffsart auf die Datei
        /// READ
        /// READ/WRITE
        /// WRITE</param>
        /// <returns>string Hashcode</returns>
        private static string GetSHA512(string Filename, FileMode fmode, FileAccess faccess)
        {
            FileStream fs = new FileStream(Filename, fmode, faccess);
            byte[] hashValue;
            
            SHA512Managed hashString = new SHA512Managed();
            string hex = "";

            hashValue = hashString.ComputeHash(fs);
            foreach (byte x in hashValue)
            {
                hex += String.Format("{0:x2}", x);
            }
            return hex;
        }
        #endregion
    }
}

MfG
Björn

PS: Danke an schoko01 !!!

Das Leben ist schön!