C# 计算字符串/文件的哈希值（MD5、SHA）

原文 C# 计算字符串的哈希值（MD5、SHA）

已做修改

一、关于本文

本文中是一个类库，包括下面几个函数：

/// 1）计算32位MD5码（大小写）：Hash_MD5_32
/// 2）计算16位MD5码（大小写）：Hash_MD5_16
/// 3）计算32位2重MD5码（大小写）：Hash_2_MD5_32
/// 4）计算16位2重MD5码（大小写）：Hash_2_MD5_16
/// 5）计算SHA-1码（大小写）：Hash_SHA_1
/// 6）计算SHA-256码（大小写）：Hash_SHA_256
/// 7）计算SHA-384码（大小写）：Hash_SHA_384
/// 8）计算SHA-512码（大小写）：Hash_SHA_512
/// 9）计算文件的 SHA256 值:SHA256File
/// 10）计算文件的 MD5 值:MD5File
/// 11）计算文件的 SHA1 值:SHA1File

编译后被打包成文件HashTools.dll，其他程序可以在添加引用后对这些函数进行调用

二、类库中各函数代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace HashTool
{
    /// <summary>
    /// C# 计算字符串/文件哈希值（MD5、SHA）
    /// 1）计算32位MD5码（大小写）：Hash_MD5_32
    /// 2）计算16位MD5码（大小写）：Hash_MD5_16
    /// 3）计算32位2重MD5码（大小写）：Hash_2_MD5_32
    /// 4）计算16位2重MD5码（大小写）：Hash_2_MD5_16
    /// 5）计算SHA-1码（大小写）：Hash_SHA_1
    /// 6）计算SHA-256码（大小写）：Hash_SHA_256
    /// 7）计算SHA-384码（大小写）：Hash_SHA_384
    /// 8）计算SHA-512码（大小写）：Hash_SHA_512
    /// 9）计算文件的 SHA256 值:SHA256File
    /// 10）计算文件的 MD5 值:MD5File
    /// 11）计算文件的 SHA1 值:SHA1File
    /// </summary>
    public class HashHelper
    {

        /// <summary>
        /// 计算32位MD5码
        /// </summary>
        /// <param name="word">字符串</param>
        /// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
        /// <returns></returns>
        public static string Hash_MD5_32(string word, bool toUpper = true)
        {
            try
            {
                System.Security.Cryptography.MD5CryptoServiceProvider MD5CSP
                    = new System.Security.Cryptography.MD5CryptoServiceProvider();

                byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
                byte[] bytHash = MD5CSP.ComputeHash(bytValue);
                MD5CSP.Clear();

                //根据计算得到的Hash码翻译为MD5码
                string sHash = "", sTemp = "";
                for (int counter = 0; counter < bytHash.Count(); counter++)
                {
                    long i = bytHash[counter] / 16;
                    if (i > 9)
                    {
                        sTemp = ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp = ((char)(i + 0x30)).ToString();
                    }
                    i = bytHash[counter] % 16;
                    if (i > 9)
                    {
                        sTemp += ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp += ((char)(i + 0x30)).ToString();
                    }
                    sHash += sTemp;
                }

                //根据大小写规则决定返回的字符串
                return toUpper ? sHash : sHash.ToLower();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        /// <summary>
        /// 计算16位MD5码
        /// </summary>
        /// <param name="word">字符串</param>
        /// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
        /// <returns></returns>
        public static string Hash_MD5_16(string word, bool toUpper = true)
        {
            try
            {
                string sHash = Hash_MD5_32(word).Substring(8, 16);
                return toUpper ? sHash : sHash.ToLower();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 计算32位2重MD5码
        /// </summary>
        /// <param name="word">字符串</param>
        /// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
        /// <returns></returns>
        public static string Hash_2_MD5_32(string word, bool toUpper = true)
        {
            try
            {
                System.Security.Cryptography.MD5CryptoServiceProvider MD5CSP
                    = new System.Security.Cryptography.MD5CryptoServiceProvider();

                byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
                byte[] bytHash = MD5CSP.ComputeHash(bytValue);

                //根据计算得到的Hash码翻译为MD5码
                string sHash = "", sTemp = "";
                for (int counter = 0; counter < bytHash.Count(); counter++)
                {
                    long i = bytHash[counter] / 16;
                    if (i > 9)
                    {
                        sTemp = ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp = ((char)(i + 0x30)).ToString();
                    }
                    i = bytHash[counter] % 16;
                    if (i > 9)
                    {
                        sTemp += ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp += ((char)(i + 0x30)).ToString();
                    }
                    sHash += sTemp;
                }

                bytValue = System.Text.Encoding.UTF8.GetBytes(sHash);
                bytHash = MD5CSP.ComputeHash(bytValue);
                MD5CSP.Clear();
                sHash = "";

                //根据计算得到的Hash码翻译为MD5码
                for (int counter = 0; counter < bytHash.Count(); counter++)
                {
                    long i = bytHash[counter] / 16;
                    if (i > 9)
                    {
                        sTemp = ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp = ((char)(i + 0x30)).ToString();
                    }
                    i = bytHash[counter] % 16;
                    if (i > 9)
                    {
                        sTemp += ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp += ((char)(i + 0x30)).ToString();
                    }
                    sHash += sTemp;
                }

                //根据大小写规则决定返回的字符串
                return toUpper ? sHash : sHash.ToLower();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 计算16位2重MD5码
        /// </summary>
        /// <param name="word">字符串</param>
        /// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
        /// <returns></returns>
        public static string Hash_2_MD5_16(string word, bool toUpper = true)
        {
            try
            {
                System.Security.Cryptography.MD5CryptoServiceProvider MD5CSP
                        = new System.Security.Cryptography.MD5CryptoServiceProvider();

                byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
                byte[] bytHash = MD5CSP.ComputeHash(bytValue);

                //根据计算得到的Hash码翻译为MD5码
                string sHash = "", sTemp = "";
                for (int counter = 0; counter < bytHash.Count(); counter++)
                {
                    long i = bytHash[counter] / 16;
                    if (i > 9)
                    {
                        sTemp = ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp = ((char)(i + 0x30)).ToString();
                    }
                    i = bytHash[counter] % 16;
                    if (i > 9)
                    {
                        sTemp += ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp += ((char)(i + 0x30)).ToString();
                    }
                    sHash += sTemp;
                }

                sHash = sHash.Substring(8, 16);

                bytValue = System.Text.Encoding.UTF8.GetBytes(sHash);
                bytHash = MD5CSP.ComputeHash(bytValue);
                MD5CSP.Clear();
                sHash = "";

                //根据计算得到的Hash码翻译为MD5码
                for (int counter = 0; counter < bytHash.Count(); counter++)
                {
                    long i = bytHash[counter] / 16;
                    if (i > 9)
                    {
                        sTemp = ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp = ((char)(i + 0x30)).ToString();
                    }
                    i = bytHash[counter] % 16;
                    if (i > 9)
                    {
                        sTemp += ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp += ((char)(i + 0x30)).ToString();
                    }
                    sHash += sTemp;
                }

                sHash = sHash.Substring(8, 16);

                //根据大小写规则决定返回的字符串
                return toUpper ? sHash : sHash.ToLower();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        /// <summary>
        /// 计算SHA-1码
        /// </summary>
        /// <param name="word">字符串</param>
        /// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
        /// <returns></returns>
        public static string Hash_SHA_1(string word, bool toUpper = true)
        {
            try
            {
                System.Security.Cryptography.SHA1CryptoServiceProvider SHA1CSP
                    = new System.Security.Cryptography.SHA1CryptoServiceProvider();

                byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
                byte[] bytHash = SHA1CSP.ComputeHash(bytValue);
                SHA1CSP.Clear();

                //根据计算得到的Hash码翻译为SHA-1码
                string sHash = "", sTemp = "";
                for (int counter = 0; counter < bytHash.Count(); counter++)
                {
                    long i = bytHash[counter] / 16;
                    if (i > 9)
                    {
                        sTemp = ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp = ((char)(i + 0x30)).ToString();
                    }
                    i = bytHash[counter] % 16;
                    if (i > 9)
                    {
                        sTemp += ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp += ((char)(i + 0x30)).ToString();
                    }
                    sHash += sTemp;
                }

                //根据大小写规则决定返回的字符串
                return toUpper ? sHash : sHash.ToLower();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        /// <summary>
        /// 计算SHA-256码
        /// </summary>
        /// <param name="word">字符串</param>
        /// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
        /// <returns></returns>
        public static string Hash_SHA_256(string word, bool toUpper = true)
        {
            try
            {
                System.Security.Cryptography.SHA256CryptoServiceProvider SHA256CSP
                    = new System.Security.Cryptography.SHA256CryptoServiceProvider();

                byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
                byte[] bytHash = SHA256CSP.ComputeHash(bytValue);
                SHA256CSP.Clear();

                //根据计算得到的Hash码翻译为SHA-1码
                string sHash = "", sTemp = "";
                for (int counter = 0; counter < bytHash.Count(); counter++)
                {
                    long i = bytHash[counter] / 16;
                    if (i > 9)
                    {
                        sTemp = ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp = ((char)(i + 0x30)).ToString();
                    }
                    i = bytHash[counter] % 16;
                    if (i > 9)
                    {
                        sTemp += ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp += ((char)(i + 0x30)).ToString();
                    }
                    sHash += sTemp;
                }

                //根据大小写规则决定返回的字符串
                return toUpper ? sHash : sHash.ToLower();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        /// <summary>
        /// 计算SHA-384码
        /// </summary>
        /// <param name="word">字符串</param>
        /// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
        /// <returns></returns>
        public static string Hash_SHA_384(string word, bool toUpper = true)
        {
            try
            {
                System.Security.Cryptography.SHA384CryptoServiceProvider SHA384CSP
                    = new System.Security.Cryptography.SHA384CryptoServiceProvider();

                byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
                byte[] bytHash = SHA384CSP.ComputeHash(bytValue);
                SHA384CSP.Clear();

                //根据计算得到的Hash码翻译为SHA-1码
                string sHash = "", sTemp = "";
                for (int counter = 0; counter < bytHash.Count(); counter++)
                {
                    long i = bytHash[counter] / 16;
                    if (i > 9)
                    {
                        sTemp = ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp = ((char)(i + 0x30)).ToString();
                    }
                    i = bytHash[counter] % 16;
                    if (i > 9)
                    {
                        sTemp += ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp += ((char)(i + 0x30)).ToString();
                    }
                    sHash += sTemp;
                }

                //根据大小写规则决定返回的字符串
                return toUpper ? sHash : sHash.ToLower();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        /// <summary>
        /// 计算SHA-512码
        /// </summary>
        /// <param name="word">字符串</param>
        /// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
        /// <returns></returns>
        public static string Hash_SHA_512(string word, bool toUpper = true)
        {
            try
            {
                System.Security.Cryptography.SHA512CryptoServiceProvider SHA512CSP
                    = new System.Security.Cryptography.SHA512CryptoServiceProvider();

                byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(word);
                byte[] bytHash = SHA512CSP.ComputeHash(bytValue);
                SHA512CSP.Clear();

                //根据计算得到的Hash码翻译为SHA-1码
                string sHash = "", sTemp = "";
                for (int counter = 0; counter < bytHash.Count(); counter++)
                {
                    long i = bytHash[counter] / 16;
                    if (i > 9)
                    {
                        sTemp = ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp = ((char)(i + 0x30)).ToString();
                    }
                    i = bytHash[counter] % 16;
                    if (i > 9)
                    {
                        sTemp += ((char)(i - 10 + 0x41)).ToString();
                    }
                    else
                    {
                        sTemp += ((char)(i + 0x30)).ToString();
                    }
                    sHash += sTemp;
                }

                //根据大小写规则决定返回的字符串
                return toUpper ? sHash : sHash.ToLower();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 计算文件的 SHA256 值
        /// </summary>
        /// <param name="fileStream">文件流</param>
        /// <returns>System.String.</returns>
        public static string SHA256File(System.IO.FileStream fileStream)
        {
            System.Security.Cryptography.SHA256 mySHA256 = System.Security.Cryptography.SHA256Managed.Create();

            byte[] hashValue;

            // Create a fileStream for the file.
            //FileStream fileStream = fInfo.Open(FileMode.Open);
            // Be sure it's positioned to the beginning of the stream.
            fileStream.Position = 0;
            // Compute the hash of the fileStream.
            hashValue = mySHA256.ComputeHash(fileStream);

            // Close the file.
            fileStream.Close();
            // Write the hash value to the Console.
            return PrintByteArray(hashValue);

        }
        /// <summary>
        /// 计算文件的 MD5 值
        /// </summary>
        /// <param name="fileName">要计算 MD5 值的文件名和路径</param>
        /// <returns>MD5 值16进制字符串</returns>
        public static string MD5File(string fileName)
        {

            return HashFile(fileName, "md5");

        }

        /// <summary>
        /// 计算文件的 sha1 值
        /// </summary>
        /// <param name="fileName">要计算 sha1 值的文件名和路径</param>
        /// <returns>sha1 值16进制字符串</returns>
        public static string SHA1File(string fileName)
        {

            return HashFile(fileName, "sha1");

        }

        /// <summary>
        /// 计算文件的哈希值
        /// </summary>
        /// <param name="fileName">要计算哈希值的文件名和路径</param>
        /// <param name="algName">算法:sha1,md5</param>
        /// <returns>哈希值16进制字符串</returns>
        private static string HashFile(string fileName, string algName)
        {

            if (!System.IO.File.Exists(fileName))

                return string.Empty;

            System.IO.FileStream fs = new System.IO.FileStream(fileName, System.IO.FileMode.Open, System.IO.FileAccess.Read);

            byte[] hashBytes = HashData(fs, algName);

            fs.Close();

            return ByteArrayToHexString(hashBytes);

        }

        /// <summary>
        /// 计算哈希值
        /// </summary>
        /// <param name="stream">要计算哈希值的 Stream</param>
        /// <param name="algName">算法:sha1,md5</param>
        /// <returns>哈希值字节数组</returns>
        private static byte[] HashData(System.IO.Stream stream, string algName)
        {

            System.Security.Cryptography.HashAlgorithm algorithm;

            if (algName == null)
            {

                throw new ArgumentNullException("algName 不能为 null");

            }

            if (string.Compare(algName, "sha1", true) == 0)
            {

                algorithm = System.Security.Cryptography.SHA1.Create();

            }

            else
            {

                if (string.Compare(algName, "md5", true) != 0)
                {

                    throw new Exception("algName 只能使用 sha1 或 md5");

                }

                algorithm = System.Security.Cryptography.MD5.Create();

            }

            return algorithm.ComputeHash(stream);

        }

        /// <summary>
        /// 字节数组转换为16进制表示的字符串
        /// </summary>
        private static string ByteArrayToHexString(byte[] buf)
        {

            return BitConverter.ToString(buf).Replace("-", "");

        }

        private static string PrintByteArray(byte[] array)
        {
            StringBuilder sb = new StringBuilder();
            int i;
            for (i = 0; i < array.Length; i++)
            {
                sb.Append(String.Format("{0:X2}", array[i]));

            }
            return sb.ToString();
        }

        /// <summary>
        ///  计算指定文件的CRC32值
        /// </summary>
        /// <param name="fileName">指定文件的完全限定名称</param>
        /// <returns>返回值的字符串形式</returns>
        public static String Crc32File(String fileName)
        {
            String hashCRC32 = String.Empty;
            //检查文件是否存在，如果文件存在则进行计算，否则返回空值
            if (System.IO.File.Exists(fileName))
            {
                using (System.IO.FileStream fs = new System.IO.FileStream(fileName, System.IO.FileMode.Open, System.IO.FileAccess.Read))
                {
                    //计算文件的CSC32值
                    Crc32 calculator = new Crc32();
                    Byte[] buffer = calculator.ComputeHash(fs);
                    calculator.Clear();
                    //将字节数组转换成十六进制的字符串形式
                    StringBuilder stringBuilder = new StringBuilder();
                    for (int i = 0; i < buffer.Length; i++)
                    {
                        stringBuilder.Append(buffer[i].ToString("X2"));
                    }
                    hashCRC32 = stringBuilder.ToString();
                }//关闭文件流
            }
            return hashCRC32;
        }

        #region Class CRC32 算法的实现
        /// <summary>
        /// 提供 CRC32 算法的实现
        /// </summary>
        private class Crc32 : System.Security.Cryptography.HashAlgorithm
        {
            public const UInt32 DefaultPolynomial = 0xedb88320;
            public const UInt32 DefaultSeed = 0xffffffff;
            private UInt32 hash;
            private UInt32 seed;
            private UInt32[] table;
            private static UInt32[] defaultTable;
            public Crc32()
            {
                table = InitializeTable(DefaultPolynomial);
                seed = DefaultSeed;
                Initialize();
            }
            public Crc32(UInt32 polynomial, UInt32 seed)
            {
                table = InitializeTable(polynomial);
                this.seed = seed;
                Initialize();
            }
            public override void Initialize()
            {
                hash = seed;
            }
            protected override void HashCore(byte[] buffer, int start, int length)
            {
                hash = CalculateHash(table, hash, buffer, start, length);
            }
            protected override byte[] HashFinal()
            {
                byte[] hashBuffer = UInt32ToBigEndianBytes(~hash);
                this.HashValue = hashBuffer;
                return hashBuffer;
            }
            public static UInt32 Compute(byte[] buffer)
            {
                return ~CalculateHash(InitializeTable(DefaultPolynomial), DefaultSeed, buffer, 0, buffer.Length);
            }
            public static UInt32 Compute(UInt32 seed, byte[] buffer)
            {
                return ~CalculateHash(InitializeTable(DefaultPolynomial), seed, buffer, 0, buffer.Length);
            }
            public static UInt32 Compute(UInt32 polynomial, UInt32 seed, byte[] buffer)
            {
                return ~CalculateHash(InitializeTable(polynomial), seed, buffer, 0, buffer.Length);
            }
            private static UInt32[] InitializeTable(UInt32 polynomial)
            {
                if (polynomial == DefaultPolynomial && defaultTable != null)
                {
                    return defaultTable;
                }
                UInt32[] createTable = new UInt32[256];
                for (int i = 0; i < 256; i++)
                {
                    UInt32 entry = (UInt32)i;
                    for (int j = 0; j < 8; j++)
                    {
                        if ((entry & 1) == 1)
                            entry = (entry >> 1) ^ polynomial;
                        else
                            entry = entry >> 1;
                    }
                    createTable[i] = entry;
                }
                if (polynomial == DefaultPolynomial)
                {
                    defaultTable = createTable;
                }
                return createTable;
            }
            private static UInt32 CalculateHash(UInt32[] table, UInt32 seed, byte[] buffer, int start, int size)
            {
                UInt32 crc = seed;
                for (int i = start; i < size; i++)
                {
                    unchecked
                    {
                        crc = (crc >> 8) ^ table[buffer[i] ^ crc & 0xff];
                    }
                }
                return crc;
            }
            private byte[] UInt32ToBigEndianBytes(UInt32 x)
            {
                return new byte[] { (byte)((x >> 24) & 0xff), (byte)((x >> 16) & 0xff), (byte)((x >> 8) & 0xff), (byte)(x & 0xff) };
            }
        }

        #endregion

    }

}

 

 

三、函数调用
建立项目ComputeHash，添加对HashTools.dll库的引用。并添加代码：

 
using HashTools;
然后在Main函数中添加下列代码：
static void Main(string[] args)
{
    Console.WriteLine("MD5 of \"abc\"");

    Console.WriteLine("MD5_32(Upper): {0}",
        HashHelper.Hash_MD5_32("abc"));
    Console.WriteLine("MD5_32(Lower): {0}",
        HashHelper.Hash_MD5_32("abc", false));

    Console.WriteLine("MD5_16(Upper): {0}",
        HashHelper.Hash_MD5_16("abc"));
    Console.WriteLine("MD5_16(Lower): {0}",
        HashHelper.Hash_MD5_16("abc", false));

    Console.WriteLine("2_MD5_32(Upper): {0}",
        HashHelper.Hash_2_MD5_32("abc"));
    Console.WriteLine("2_MD5_32(Lower): {0}",
        HashHelper.Hash_2_MD5_32("abc", false));

    Console.WriteLine("2_MD5_32(Upper): {0}",
        HashHelper.Hash_2_MD5_16("abc"));
    Console.WriteLine("2_MD5_32(Lower): {0}",
        HashHelper.Hash_2_MD5_16("abc", false));

    Console.WriteLine("SHA of \"abc\"");

    Console.WriteLine("SHA-1(Upper): {0}",
        HashHelper.Hash_SHA_1("abc"));
    Console.WriteLine("SHA-1(Lower): {0}",
        HashHelper.Hash_SHA_1("abc", false));

    Console.WriteLine("SHA-256(Upper): {0}",
        HashHelper.Hash_SHA_256("abc"));
    Console.WriteLine("SHA-256(Lower): {0}",
        HashHelper.Hash_SHA_256("abc", false));

    Console.WriteLine("SHA-384(Upper): {0}",
        HashHelper.Hash_SHA_384("abc"));
    Console.WriteLine("SHA-384(Lower): {0}",
        HashHelper.Hash_SHA_384("abc", false));

    Console.WriteLine("SHA-512(Upper): {0}",
        HashHelper.Hash_SHA_512("abc"));
    Console.WriteLine("SHA-512(Lower): {0}",
        HashHelper.Hash_SHA_512("abc", false));

    Console.ReadLine();
}
运行结果如下：

 
END

 

时间： 2024-07-28 13:55:08

C# 计算字符串/文件的哈希值（MD5、SHA）的相关文章

文件的哈希值不在指定的目录文件中。此文件可能已损坏或被篡（Windows10 /Windows8.1）

 ------------------------------------------Windows10------------------------------------------------ win10系统下,很多用户都在问禁用驱动程序强制签名的问题,确实,设置起来有点复杂,需要用户多点耐心. 那么下面就来看看win10系统下禁用驱动程序强制签名的方法步骤. win10 准备: 1.进行下面操作前,请关闭所有正在运行的程序. 第一步.点开开始菜单,点击里面的电脑设置,没有的话,点击所有

hash 哈希值-java实现.net中的哈希值计算

问题描述 java实现.net中的哈希值计算 在.net 中有 HashAlgorithm.Create(""SHA1"").ComputeHash(data) 来计算字节数组的哈希值,返回字节数组,请问在java中该如何实现同样的功能 解决方案 http://www.micmiu.com/lang/java/java-md5-sha1/ 解决方案二: java的serversocket.net实现方式

Visual C# 2005中如何产生与比较哈希值

借助于System.Security.Cryptography命名空间的密码资源,将非常容易产生与比较哈希值.因为所有的哈希函数都接收类型为 Byte() 的输入,因此可能需要将初始数据转换成一个字节数组才能够为它产生哈希值.欲为一个字符串值建立一个哈希值,请依下列步骤进行: 1.使用Using语句导入System.System.Security.System.Security.Cryptographic与System.Text命名空间,这样一来,您才不需要于程序代码中编写一长串的完整名称: u

安装VSTO文件时，提示为文件dll计算出的哈希值与清单中的指定值不同

问题描述 用VS2010生成的VSTO文件,安装时提示错误:为文件Word.UI.dll计算出的哈希值与清单中的指定值不同.项目也没有使用clickonce发布,详细提示如下:System.Deployment.Application.InvalidDeploymentException:为文件Word.UI.dll计算出的哈希值与清单中的指定值不同.在Microsoft.VisualStudio.Tools.Applications.Deployment.ClickOnceAddInDeplo

lua可以计算字符串的hash值么？

问题描述 lua可以计算字符串的hash值么? 小弟在用lua写个脚本需要根据字符串的哈希值进行分组,找了半天也没找到相关的库函数,请问使用lua怎么能得出字符串的hash值呢?

什么是哈希值

许多朋友不知道哈希值是什么,想知道哈希值怎么用,小编这里就做一下科普. 哈希值是什么 哈希值就是文件的身份证,不过比身份证还严格.他是根据文件大小,时间,类型,创作着,机器等计算出来的,很容易就会发生变化,谁也不能预料下一个号码是多少,也没有更改他的软件.哈希算法将任意长度的二进制值映射为固定长度的较小二进制值,这个小的二进制值称为哈希值.哈希值是一段数据唯一且极其紧凑的数值表示形式.如果散列一段明文而且哪怕只更改该段落的一个字母,随后的哈希都将产生不同的值.要找到散列为同一个值的两个不同的输入

js 判断字符串长度:计算字符串长度/判断空

计算字符串长度可用的三种方法:   echo "$str"awk '{print length($0)}'  expr length "$str"  echo "$str"wc -c  但是第三种得出的值会多1,可能是把结束符也计算在内了. 判断字符串为空的方法有三种:   if [ "$str" = "" ]  if [ x"$str" = x ]  if [ -z "$st

小工具：计算当前文件夹中，有多少行JS代码和ASP代码，并且还可统计代码有多少字节

js|统计 计算当前文件夹中,有多少行JS代码和ASP代码,并且还可统计代码有多少字节 有示例代码 <%'\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'\\'\\    from codeproject.com'\\    calculate code'\\    bluedestiny'\\    mail:bluedestiny at 126.com'\\'\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ opt

用C语言编写函数计算子字符串substr在主字符串mainstr中的索引值

在大小写敏感的前提下,用C语言编写函数计算子字符串substr在主字符串mainstr中的索引值. 如果substr完全包含在mainstr中,请计算出索引值.否则,返回-1. 具体代码如下: findstr.c /** Author: snowdream <yanghui1986527@gmail.com> Data: 2012.03.05 Description: 假设一个主要字符串"Hello World!",和一个子字符串"World". 在大小