DES、RSA、RSA数字签名、MD5、SHA 加密解密代码

最新推荐文章于 2022-06-15 07:56:49 发布
置顶 最新推荐文章于 2022-06-15 07:56:49 发布
阅读量2k 收藏 2
点赞数
CC 4.0 BY-SA版权
文章标签： md5 RSA RSA数字签名 SHA DES
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Icelove111/article/details/38335845
本文介绍了多种加密解密方法，包括DES和RSA算法的应用，以及如何使用RSA进行数字签名和验证。此外还提供了MD5和SHA系列哈希算法的使用方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

/// <summary>
    /// 作者：李照
    /// 时间：2014-06-05 15:56:23
    /// </summary>
    public static class EncryptionDecryption
    {
        #region 将byte[]数组转换为字符串
        /// <summary>
        /// 将byte[]数组转换为字符串，与FromBaseString()方法互逆
        /// </summary>
        /// <param name="inArray">需要转换的数组</param>
        /// <returns>返回字符串</returns>
        public static string ToBaseSting(byte[] inArray)
        {
            StringBuilder sb = new StringBuilder();
            foreach (byte b in inArray.ToArray())
            {
                sb.AppendFormat("{0:X2}", b);
            }
            return sb.ToString();
        }
        #endregion
        #region 将字符串转换为byte[]数组
        /// <summary>
        /// 将字符串转换为byte[]数组，与ToBaseSting()方法互逆
        /// </summary>
        /// <param name="s">需要转换的字符串</param>
        /// <returns>返回数组</returns>
        public static byte[] FromBaseString(string s)
        {
            byte[] inputByteArray = new byte[s.Length / 2];
            for (int x = 0; x < s.Length / 2; x++)
            {
                int i = (Convert.ToInt32(s.Substring(x * 2, 2), 16));
                inputByteArray[x] = (byte)i;
            }
            return inputByteArray;
        }
        #endregion
        #region DES加密解密
        #region 字符串加密
        /// <summary>
        /// DES加密--字符串
        /// </summary>
        /// <param name="encryptString">加密的字符串</param>
        /// <param name="sKey">密钥，要求为8位数</param>
        /// <returns>加密成功返回加密后的字符串，失败返回源串</returns>
        public static string DESEncrypt(string encryptString, string sKey)
        {
            try
            {
                byte[] inputByteArray = Encoding.Default.GetBytes(encryptString);
                using (DESCryptoServiceProvider des = new DESCryptoServiceProvider()
                {
                    Key = Encoding.Default.GetBytes(sKey.Substring(0, 8)),
                    IV = Encoding.Default.GetBytes(sKey.Substring(0, 8))
                })
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
                        {
                            cs.Write(inputByteArray, 0, inputByteArray.Length);
                            cs.FlushFinalBlock();
                            StringBuilder ret = new StringBuilder();
                            foreach (byte b in ms.ToArray())
                            {
                                ret.AppendFormat("{0:X2}", b);
                            }
                            //ret.ToString();
                            return ret.ToString();
                            //return Convert.ToBase64String(ms.ToArray());
                        }
                    }
                }

            }
            catch (Exception)
            {
                return encryptString;
            }
        }
        #endregion

        #region 字符串解密
        /// <summary>
        /// DES解密--字符串
        /// </summary>
        /// <param name="decryptString">解密字符串</param>
        /// <param name="sKey">揭秘密钥，要求8位和加密时相同</param>
        /// <returns>解密成功返回解密后的字符串，失败返源串</returns>
        public static string DESDecrypt(string decryptString, string sKey)
        {

            try
            {
                string result;
                //byte[] inputByteArray = Convert.FromBase64String(decryptString);
                byte[] inputByteArray = new byte[decryptString.Length / 2];
                for (int x = 0; x < decryptString.Length / 2; x++)
                {
                    int i = (Convert.ToInt32(decryptString.Substring(x * 2, 2), 16));
                    inputByteArray[x] = (byte)i;
                }
                using (DESCryptoServiceProvider des = new DESCryptoServiceProvider()
                {
                    Key = Encoding.Default.GetBytes(sKey.Substring(0, 8)),
                    IV = Encoding.Default.GetBytes(sKey.Substring(0, 8))
                })
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
                        {
                            cs.Write(inputByteArray, 0, inputByteArray.Length);
                            cs.FlushFinalBlock();
                            result = Encoding.Default.GetString(ms.ToArray());
                        }
                    }
                }
                return result;
            }
            catch
            {
                return decryptString;
            }
        }
        #endregion

        #region 文件内容加密
        /// <summary>
        /// 文件加密   原理：将文件A内容复制到临时文件B，对B文件流循环进行读取，并把读取的文件流加密
        /// </summary>
        /// <param name="inFile">加密前文件的绝对路径</param>
        /// <param name="outFile">加密后文件的绝对路径</param>
        /// <param name="sKey">密钥要求为8位数</param>
        /// <returns>返回加密结果</returns>
        public static bool DESEncryptFile(string inFile, string outFile, string sKey)
        {
            try
            {
                if (!File.Exists(inFile))
                    return false;
                //读入流
                FileStream inFs = new FileStream(inFile, FileMode.Open, FileAccess.Read);
                //待写入流
                FileStream outFs = new FileStream(outFile, FileMode.Open, FileAccess.Write);
                outFs.SetLength(0);
                byte[] byteIn = new byte[100];
                long readLenght = 0;//当前读入流的长度
                long readSumLenght = inFs.Length;//读入流的总长度
                int everyLenght = 0;//每次读入流的长度
                using (DESCryptoServiceProvider des = new DESCryptoServiceProvider()
                {
                    Key = Encoding.Default.GetBytes(sKey.Substring(0, 8)),
                    IV = Encoding.Default.GetBytes(sKey.Substring(0, 8))
                })
                {
                    using (CryptoStream cs = new CryptoStream(outFs, des.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        while (readLenght < readSumLenght)
                        {
                            everyLenght = inFs.Read(byteIn, 0, 100);
                            cs.Write(byteIn, 0, everyLenght);
                            readLenght += everyLenght;
                        }
                        cs.Close();
                        inFs.Close();
                        outFs.Close();
                        return true;
                    }
                }
            }
            catch (Exception)
            {

                return false;
            }
        }
        #endregion

        #region 文件内容解密
        /// <summary>
        /// 解密 -- 原理：将文件A内容复制到临时文件B，对B文件流循环进行读取，并把读取的文件流解密
        /// </summary>
        /// <param name="inFile">加密前文件的绝对路径</param>
        /// <param name="outFile">加密后文件的绝对路径</param>
        /// <param name="sKey">密钥要求为8位数</param>
        /// <returns></returns>
        public static bool DESDecryptFile(string inFile, string outFile, string sKey)
        {
            try
            {
                if (!File.Exists(inFile))
                    return false;
                //读入流
                FileStream inFs = new FileStream(inFile, FileMode.Open, FileAccess.Read);
                //待写入流
                FileStream outFs = new FileStream(outFile, FileMode.Open, FileAccess.Write);
                outFs.SetLength(0);
                byte[] byteIn = new byte[100];
                long readLenght = 0;//当前读入流的长度
                long readSumLenght = inFs.Length;//读入流的总长度
                int everyLenght = 0;//每次读入流的长度
                using (DESCryptoServiceProvider des = new DESCryptoServiceProvider()
                {
                    Key = Encoding.Default.GetBytes(sKey.Substring(0, 8)),
                    IV = Encoding.Default.GetBytes(sKey.Substring(0, 8))
                })
                {
                    using (CryptoStream cs = new CryptoStream(outFs, des.CreateDecryptor(), CryptoStreamMode.Write))
                    {
                        //循环读取流
                        while (readLenght < readSumLenght)
                        {
                            everyLenght = inFs.Read(byteIn, 0, 100);
                            cs.Write(byteIn, 0, everyLenght);
                            readLenght += everyLenght;
                        }
                        cs.Close();
                        inFs.Close();
                        outFs.Close();
                    }
                }
                return true;
            }
            catch
            {
                return false;
            }
        }
        #endregion
        #endregion

        #region RSA 加密解密
        #region RSA 的密钥产成
        /// <summary>
        /// RSA 的密钥产生 产生私钥 和公钥 
        /// </summary>
        /// <param name="xmlKeys"></param>
        /// <param name="xmlPublicKey"></param>
        public static void RSAKey(out string xmlKeys, out string xmlPublicKey)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            xmlKeys = rsa.ToXmlString(true);
            xmlPublicKey = rsa.ToXmlString(false);
        }
        #endregion
        #region RSA加密
        /// <summary>
        /// RSA加密----字符串
        /// 说明KEY必须是XML的行式,返回的是字符串 
        /// 在有一点需要说明！！该加密方式有长度限制的！！ 
        /// </summary>
        /// <param name="encryptString">要加密的字符串</param>
        /// <param name="publicKey">公钥</param>
        /// <returns>加密后的字符串</returns>
        public static string RSAEncrypt(string encryptString, string publicKey)
        {
            string result;
            byte[] byteEncrypt;
            byte[] byteCypher;
            try
            {
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.FromXmlString(publicKey);
                byteEncrypt = (new UnicodeEncoding()).GetBytes(encryptString);
                //byteEncrypt = Encoding.GetEncoding("gb2312").GetBytes(encryptString);
                byteCypher = rsa.Encrypt(byteEncrypt, false);
                result = Convert.ToBase64String(byteCypher);
            }
            catch (Exception)
            {

                result = encryptString;
            }
            return result;
        }
        /// <summary>
        /// RSA加密----数组
        /// </summary>
        /// <param name="byteEncrypt">要加密的数组</param>
        /// <param name="publicKey">公钥</param>
        /// <returns>加密后的字符串</returns>
        public static string RSAEncrypt(byte[] byteEncrypt, string publicKey)
        {
            string result;
            byte[] byteCypher;
            try
            {
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.FromXmlString(publicKey);
                byteCypher = rsa.Encrypt(byteEncrypt, false);
                result = Convert.ToBase64String(byteCypher);
            }
            catch (Exception)
            {
                result = byteEncrypt.ToString();
            }
            return result;
        }

        #endregion
        #region RSA解密
        /// <summary>
        /// RSA解密--字符串
        /// </summary>
        /// <param name="decryptString">要解密的字符串</param>
        /// <param name="privateKey">私钥</param>
        /// <returns>解密后的字符串</returns>
        public static string RSADecrypt(string decryptString, string privateKey)
        {
            string result;
            byte[] byteDecrypt;
            byte[] byteDypher;
            try
            {
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.FromXmlString(privateKey);
                byteDecrypt = Convert.FromBase64String(decryptString);
                byteDypher = rsa.Decrypt(byteDecrypt, false);
                result = (new UnicodeEncoding()).GetString(byteDypher);
            }
            catch (Exception)
            {
                result = decryptString;
            }
            return result;
        }
        /// <summary>
        /// RSA解密--数组
        /// </summary>
        /// <param name="decryptString">要解密的数组</param>
        /// <param name="privateKey">私钥</param>
        /// <returns>解密后的字符串</returns>
        public static string RSADecrypt(byte[] byteDecrypt, string privateKey)
        {
            string result;
            byte[] byteDypher;
            try
            {
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.FromXmlString(privateKey);
                byteDypher = rsa.Decrypt(byteDecrypt, false);
                result = (new UnicodeEncoding()).GetString(byteDypher);
            }
            catch (Exception)
            {
                result = byteDecrypt.ToString();
            }
            return result;
        }
        #endregion
        #endregion

        #region RSA数字签名
        #region 获取MD5的Hash描述表
        /// <summary>
        /// 从字符串获取MD5的Hash描述表
        /// </summary>
        /// <param name="stringSource">需要获取的字符串</param>
        /// <param name="result">从字符串中取得MD5的Hash描述</param>
        /// <returns>true 获取成功 false 获取失败</returns>
        public static bool GetHash(string stringSource, ref byte[] result)
        {
            //从字符串中取得MD5的Hash描述 
            byte[] Buffer;
            HashAlgorithm MD5 = HashAlgorithm.Create("MD5");
            Buffer = System.Text.Encoding.GetEncoding("GB2312").GetBytes(stringSource);
            result = MD5.ComputeHash(Buffer);

            return true;
        }

        /// <summary>
        /// 从字符串获取MD5的Hash描述表
        /// </summary>
        /// <param name="stringSource">需要获取的字符串</param>
        /// <param name="result">从字符串中取得MD5的Hash描述 </param>
        /// <returns>true 获取成功 false 获取失败</returns>
        public static bool GetHash(string stringSource, ref string result)
        {

            //从字符串中取得MD5的Hash描述 
            byte[] Buffer;
            byte[] HashData;
            HashAlgorithm MD5 = HashAlgorithm.Create("MD5");
            Buffer = System.Text.Encoding.GetEncoding("GB2312").GetBytes(stringSource);
            HashData = MD5.ComputeHash(Buffer);

            result = Convert.ToBase64String(HashData);
            return true;

        }

        /// <summary>
        /// 从文件获取MD5的Hash描述表
        /// </summary>
        /// <param name="objFile">需要获取的文件</param>
        /// <param name="result">从文件中取得MD5的Hash描述 </param>
        /// <returns>true 获取成功 false 获取失败</returns>
        public static bool GetHash(FileStream objFile, ref byte[] result)
        {

            //从文件中取得MD5的Hash描述 
            HashAlgorithm MD5 = HashAlgorithm.Create("MD5");
            result = MD5.ComputeHash(objFile);
            objFile.Close();

            return true;

        }

        /// <summary>
        /// 从文件获取MD5的Hash描述表
        /// </summary>
        /// <param name="objFile">需要获取的文件</param>
        /// <param name="result">从文件中取得MD5的Hash描述 </param>
        /// <returns>true 获取成功 false 获取失败</returns>
        public static bool GetHash(System.IO.FileStream objFile, ref string result)
        {
            byte[] HashData;
            HashAlgorithm MD5 = HashAlgorithm.Create("MD5");
            HashData = MD5.ComputeHash(objFile);
            objFile.Close();

            result = Convert.ToBase64String(HashData);

            return true;

        }
        #endregion

        #region RSA签名
        /// <summary>
        /// RSA签名
        /// </summary>
        /// <param name="privateKey">私钥</param>
        /// <param name="eSignatureString">MD5加密后的哈希描述表 字符串(签名前的数据)</param>
        /// <param name="result">返回加密后签名字符串</param>
        /// <returns>是否成功签名</returns>
        public static bool RSASignature(string privateKey, string eSignatureString, ref string result)
        {
            byte[] HashbyteSignature;
            byte[] EncryptedSignatureData;
            try
            {
                HashbyteSignature = Convert.FromBase64String(eSignatureString);
                RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
                RSA.FromXmlString(privateKey);
                RSAPKCS1SignatureFormatter RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
                //设置签名的算法为MD5 
                RSAFormatter.SetHashAlgorithm("MD5");
                //执行签名 
                EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);
                result = Convert.ToBase64String(EncryptedSignatureData);
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
        /// <summary>
        /// RSA签名
        /// </summary>
        /// <param name="privateKey">私钥</param>
        /// <param name="eSignatureString">MD5加密后的哈希描述表 字符串(签名前的数据)</param>
        /// <param name="result">返回加密后签名数组</param>
        /// <returns>是否成功签名</returns>
        public static bool RSASignature(string privateKey, string eSignatureString, ref byte[] result)
        {
            byte[] HashbyteSignature;
            try
            {
                HashbyteSignature = Convert.FromBase64String(eSignatureString);
                RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
                RSA.FromXmlString(privateKey);
                RSAPKCS1SignatureFormatter RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
                //设置签名的算法为MD5 
                RSAFormatter.SetHashAlgorithm("MD5");
                //执行签名 
                result = RSAFormatter.CreateSignature(HashbyteSignature);
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
        /// <summary>
        /// RSA签名
        /// </summary>
        /// <param name="privateKey">私钥</param>
        /// <param name="HashbyteSignature">MD5加密后的哈希描述表 数组(签名前的数据)</param>
        /// <param name="result">返回加密后签名数组</param>
        /// <returns>是否成功签名</returns>natureString"></param>
        public static bool RSASignature(string privateKey, byte[] eSignatureString, ref byte[] result)
        {
            try
            {
                RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
                RSA.FromXmlString(privateKey);
                RSAPKCS1SignatureFormatter RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
                //设置签名的算法为MD5 
                RSAFormatter.SetHashAlgorithm("MD5");
                //执行签名 
                result = RSAFormatter.CreateSignature(eSignatureString);
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
        /// <summary>
        /// RSA签名
        /// </summary>
        /// <param name="privateKey">私钥</param>
        /// <param name="eSignatureString">MD5加密后的哈希描述表 数组(签名前的数据)</param>
        /// <param name="result">返回加密后签名字符串</param>
        /// <returns>是否成功签名</returns>
        public static bool RSASignature(string privateKey, byte[] eSignatureString, ref string result)
        {
            byte[] EncryptedSignatureData;
            try
            {
                RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
                RSA.FromXmlString(privateKey);
                RSAPKCS1SignatureFormatter RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
                //设置签名的算法为MD5 
                RSAFormatter.SetHashAlgorithm("MD5");
                //执行签名 
                EncryptedSignatureData = RSAFormatter.CreateSignature(eSignatureString);
                result = Convert.ToBase64String(EncryptedSignatureData);
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
        #endregion

        #region RSA 签名验证

        /// <summary>
        /// RSA 签名验证
        /// </summary>
        /// <param name="publicKey">公钥</param>
        /// <param name="dSignatureString">MD5加密后的哈希描述表 字符串(签名前的数据)</param>
        /// <param name="dSignatureData">需要验证的签名数据  字符串 (签名后的数据)</param>
        /// <returns>验证结果 true 验证成功   false 验证失败</returns>
        public static bool RSASignatureValidation(string publicKey, string dSignatureString, string dSignatureData)
        {
            byte[] DeformatterData;
            byte[] HashbyteDeformatter;
            HashbyteDeformatter = Convert.FromBase64String(dSignatureString);
            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
            RSA.FromXmlString(publicKey);
            RSAPKCS1SignatureDeformatter RSADeformatter = new RSAPKCS1SignatureDeformatter(RSA);
            //指定解密的时候HASH算法为MD5 
            RSADeformatter.SetHashAlgorithm("MD5");

            DeformatterData = Convert.FromBase64String(dSignatureData);

            if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
            {
                return true;
            }
            else
            {
                return false;
            }

        }

        /// <summary>
        /// RSA 签名验证
        /// </summary>
        /// <param name="publicKey">公钥</param>
        /// <param name="dSignatureString">MD5加密后的哈希描述表 数组(签名前的数据)</param>
        /// <param name="dSignatureData">需要验证的签名数据  字符串  (签名后的数据)</param>
        /// <returns>验证结果 true 验证成功   false 验证失败</returns>
        public static bool RSASignatureValidation(string publicKey, byte[] dSignatureString, string dSignatureData)
        {

            byte[] DeformatterData;

            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();

            RSA.FromXmlString(publicKey);
            RSAPKCS1SignatureDeformatter RSADeformatter = new RSAPKCS1SignatureDeformatter(RSA);
            //指定解密的时候HASH算法为MD5 
            RSADeformatter.SetHashAlgorithm("MD5");

            DeformatterData = Convert.FromBase64String(dSignatureData);

            if (RSADeformatter.VerifySignature(dSignatureString, DeformatterData))
            {
                return true;
            }
            else
            {
                return false;
            }

        }

        /// <summary>
        ///  RSA 签名验证
        /// </summary>
        /// <param name="publicKey">公钥</param>
        /// <param name="dSignatureString">MD5加密后的哈希描述表 数组(签名前的数据)</param>
        /// <param name="dSignatureData">需要验证的签名数据  数组 (签名后的数据)</param>
        /// <returns>验证结果 true 验证成功   false 验证失败</returns>
        public static bool RSASignatureValidation(string publicKey, byte[] dSignatureString, byte[] dSignatureData)
        {
            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();

            RSA.FromXmlString(publicKey);
            RSAPKCS1SignatureDeformatter RSADeformatter = new RSAPKCS1SignatureDeformatter(RSA);
            //指定解密的时候HASH算法为MD5 
            RSADeformatter.SetHashAlgorithm("MD5");

            if (RSADeformatter.VerifySignature(dSignatureString, dSignatureData))
            {
                return true;
            }
            else
            {
                return false;
            }

        }

        /// <summary>
        /// RSA 签名验证
        /// </summary>
        /// <param name="publicKey">公钥</param>
        /// <param name="dSignatureString">MD5加密后的哈希描述表 字符串(签名前的数据)</param>
        /// <param name="dSignatureData">需要验证的签名数据  数组  (签名后的数据)</param>
        /// <returns>验证结果 true 验证成功   false 验证失败</returns>
        public static bool RSASignatureValidation(string publicKey, string dSignatureString, byte[] dSignatureData)
        {

            byte[] HashbyteDeformatter;

            HashbyteDeformatter = Convert.FromBase64String(dSignatureString);

            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();

            RSA.FromXmlString(publicKey);
            RSAPKCS1SignatureDeformatter RSADeformatter = new RSAPKCS1SignatureDeformatter(RSA);
            //指定解密的时候HASH算法为MD5 
            RSADeformatter.SetHashAlgorithm("MD5");

            if (RSADeformatter.VerifySignature(HashbyteDeformatter, dSignatureData))
            {
                return true;
            }
            else
            {
                return false;
            }

        }
        #endregion
        #endregion
        #region MD5加密
        /// <summary>
        /// MD5加密
        /// </summary>
        /// <param name="encryptString">加密的字符串或文件绝对路径</param>
        /// <param name="encryptType">加密类型：1 字符串  2 程序or文件</param>
        /// <param name="encryptLength">加密的长度1 16位  2 32位</param>
        /// <param name="result"></param>
        /// <returns></returns>
        public static bool MD5Encrypt(string encryptString, int encryptType, int encryptLength, ref string result)
        {
            try
            {
                using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
                {
                    switch (encryptLength)
                    {
                        case 1:
                            if (encryptType == 1)
                            {
                                result = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(encryptString)), 4, 8).Replace("-", "");
                            }
                            else if (encryptType == 2)
                            {
                                FileStream file = File.OpenRead(encryptString);
                                byte[] hash = md5.ComputeHash(file);
                                result = System.BitConverter.ToString(hash, 4, 8).Replace("-", "");
                            }
                            break;
                        case 2:
                            if (encryptType == 1)
                            {
                                result = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(encryptString))).Replace("-", "");
                            }
                            else if (encryptType == 2)
                            {
                                FileStream file = File.OpenRead(encryptString);
                                byte[] hash = md5.ComputeHash(file);
                                result = System.BitConverter.ToString(hash).Replace("-", "");
                            }
                            break;
                        default:
                            break;
                    }
                }
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
        #endregion

        #region SHA加密
        /// <summary>
        /// SHA加密
        /// </summary>
        /// <param name="encryptString">需要加密的字符串</param>
        /// <param name="encryptLength">加密的长度 1 输出160bit  SHA256输出256bit SHA384输出384bit SHA512输出512bit</param>
        /// <param name="result">加密后的字符串</param>
        /// <returns>返回加密结果 true 加密成功  false 加密失败</returns>
        public static bool SHAEncrypt(string encryptString, int encryptLength, ref string result)
        {
            byte[] resultByte;
            byte[] encryptByte = Encoding.UTF8.GetBytes(encryptString); ;
            try
            {
                switch (encryptLength)
                {
                    case 1:
                        using (SHA1Managed sha = new SHA1Managed())
                        {
                            resultByte = sha.ComputeHash(encryptByte);
                            result = Convert.ToBase64String(resultByte);
                        }
                        break;
                    case 256:
                        using (SHA256Managed sha = new SHA256Managed())
                        {
                            resultByte = sha.ComputeHash(encryptByte);
                            result = Convert.ToBase64String(resultByte);
                        }
                        break;
                    case 384:
                        using (SHA384Managed sha = new SHA384Managed())
                        {
                            resultByte = sha.ComputeHash(encryptByte);
                            result = Convert.ToBase64String(resultByte);
                        }
                        break;
                    case 512:
                        using (SHA512Managed sha = new SHA512Managed())
                        {
                            resultByte = sha.ComputeHash(encryptByte);
                            result = Convert.ToBase64String(resultByte);
                        }
                        break;
                    default:
                        break;
                }
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
        /// <summary>
        /// SHA加密
        /// </summary>
        /// <param name="encryptString">需要加密的数组</param>
        /// <param name="encryptLength">加密的长度 1 输出160bit  SHA256输出256bit SHA384输出384bit SHA512输出512bit</param>
        /// <param name="result">加密后的字符串</param>
        /// <returns>返回加密结果 true 加密成功  false 加密失败</returns>
        public static bool SHAEncrypt(byte[] encryptString, int encryptLength, ref string result)
        {
            byte[] resultByte;
            try
            {
                switch (encryptLength)
                {
                    case 1:
                        using (SHA1Managed sha = new SHA1Managed())
                        {
                            resultByte = sha.ComputeHash(encryptString);
                            result = Convert.ToBase64String(resultByte);
                        }
                        break;
                    case 256:
                        using (SHA256Managed sha = new SHA256Managed())
                        {
                            resultByte = sha.ComputeHash(encryptString);
                            result = Convert.ToBase64String(resultByte);
                        }
                        break;
                    case 384:
                        using (SHA384Managed sha = new SHA384Managed())
                        {
                            resultByte = sha.ComputeHash(encryptString);
                            result = Convert.ToBase64String(resultByte);
                        }
                        break;
                    case 512:
                        using (SHA512Managed sha = new SHA512Managed())
                        {
                            resultByte = sha.ComputeHash(encryptString);
                            result = Convert.ToBase64String(resultByte);
                        }
                        break;
                    default:
                        break;
                }
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
        /// <summary>
        /// SHA加密
        /// </summary>
        /// <param name="encryptString">需要加密的字符串</param>
        /// <param name="encryptLength">加密的长度 1 输出160bit  SHA256输出256bit SHA384输出384bit SHA512输出512bit</param>
        /// <param name="result">加密后的数组</param>
        /// <returns>返回加密结果 true 加密成功  false 加密失败</returns>
        public static bool SHAEncrypt(string encryptString, int encryptLength, ref byte[] result)
        {

            byte[] encryptByte = Encoding.UTF8.GetBytes(encryptString); ;
            try
            {
                switch (encryptLength)
                {
                    case 1:
                        using (SHA1Managed sha = new SHA1Managed())
                        {
                            result = sha.ComputeHash(encryptByte);
                        }
                        break;
                    case 256:
                        using (SHA256Managed sha = new SHA256Managed())
                        {
                            result = sha.ComputeHash(encryptByte);
                        }
                        break;
                    case 384:
                        using (SHA384Managed sha = new SHA384Managed())
                        {
                            result = sha.ComputeHash(encryptByte);
                        }
                        break;
                    case 512:
                        using (SHA512Managed sha = new SHA512Managed())
                        {
                            result = sha.ComputeHash(encryptByte);
                        }
                        break;
                    default:
                        break;
                }
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
        /// <summary>
        /// SHA加密
        /// </summary>
        /// <param name="encryptString">需要加密的数组</param>
        /// <param name="encryptLength">加密的长度 1 输出160bit  SHA256输出256bit SHA384输出384bit SHA512输出512bit</param>
        /// <param name="result">加密后的数组</param>
        /// <returns>返回加密结果 true 加密成功  false 加密失败</returns>
        public static bool SHAEncrypt(byte[] encryptString, int encryptLength, ref byte[] result)
        {
            try
            {
                switch (encryptLength)
                {
                    case 1:
                        using (SHA1Managed sha = new SHA1Managed())
                        {
                            result = sha.ComputeHash(encryptString);
                        }
                        break;
                    case 256:
                        using (SHA256Managed sha = new SHA256Managed())
                        {
                            result = sha.ComputeHash(encryptString);
                        }
                        break;
                    case 384:
                        using (SHA384Managed sha = new SHA384Managed())
                        {
                            result = sha.ComputeHash(encryptString);
                        }
                        break;
                    case 512:
                        using (SHA512Managed sha = new SHA512Managed())
                        {
                            result = sha.ComputeHash(encryptString);
                        }
                        break;
                    default:
                        break;
                }
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
        #endregion
    }
ChainFans
关注
RSA DES 公钥 数字签名
Leon的专栏
03-18 2957
RSA：         RSA机制是一种公开密钥密码体制。所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。 RSA用到的公式和定理： 　　一、数和互为素数 　　任何大于1的整数a能被因式分解为如下唯一形式：a=p1p2…pl(p1,p2，…，pl为素数） 　　二、模运算 　　①{[a(m
RSA数字签名算法的具体实现
07-12
本代码主要用于实现RSA数字签名算法，用java进行编程，能够完整的在eclipse上运行，具体可用于密码学的课程设计等。
rsa数字签名
09-19
RSA数字签名，对明文进行数字化，签名和验证，C语言，可直接运行。有界面，在文本框输入需签名的明文，再通过按钮进行操作。
RSA、DES混合加密解决方案、数字签名
05-19
RSA、DES混合加密解决方案、数字签名，该文件包含远吗和可直接使用的jar。功能包扩 0、程序自动生成公私钥。 1、客户端 公钥加密 2、服务端 私钥解密数据获取内容3、服务端私钥加密数据4、客户端公钥解密 5、私钥签名过程 6、公钥校验签名
sha1-md5 加解密代码
05-26
sha1-md5 加密源代码 ，可以直接加入用
跨平台 AES MD5 ECC DES RSA 加密解密 支持 进度 支持多种编码.源码.FlyUtils_md5加密解密工具类
01-09
本文将详细介绍标题和描述中提到的几种加密算法：AES、MD5、ECC、DES以及RSA，并结合源码库"FlyUtils"探讨它们在跨平台环境下的应用，以及如何支持进度显示和多种编码。 首先，AES（Advanced Encryption Standard）...
ios常见加密解密方法（RSA、DES 、AES、MD5）
08-31
本文将详细介绍几种常见的加密解密方法，包括RSA、DES、AES以及MD5，并针对iOS环境中的具体使用情况进行分析。 首先，RSA是一种非对称加密算法，其特点是拥有两个密钥&mdash;&mdash;公钥和私钥。公钥用于加密，私钥用于解密。...
Vue-常用加密(MD5,DES,SHA256,BASE64,SHA1,RSA)
11-29
Vue-常用加密（MD5, DES, SHA256, BASE64, SHA1, RSA） Vue 中常见的加密算法可以分成三类：对称加密算法、非对称加密算法和 Hash 算法。下面将详细介绍每种加密算法的特点、优点和缺点，以及它们的应用场景。 一...
基于Base64,MD5,SHA,Hmac,DES,AES,RSA信息加密的设计与实现的Android应用
最新发布
12-07
实现SHA1,SHA256,SHA384,SHA512对于文字的加密。 实现HmacMD5,HmacSHA1,HmacSHA256,HmacSHA384,HmacSHA512对于文字的加密。 实现了对称加密算法DES和AES. 实现了非对称加密算法RSA. - 不懂运行，下载完可以私聊问，...
密码学中AES\DES\MD5\SHA1\RSA加密流程的JAVA实现
01-07
本文将详细解析标题所提及的AES、DES、MD5、SHA1和RSA加密流程，并结合给定的Java实现进行讨论。 1. **AES（Advanced Encryption Standard）**：AES是一种对称加密算法，广泛用于保护大量数据的安全。它基于替换和...
Java中常用的加密算法MD5,SHA,RSA
09-16
Java中常用的加密算法MD5,SHA,RSA
编程实现RSA数字签名
my0214163的博客
06-15 4122
一、实验目的：理解RSA数字签名，并运用编程实现RSA数字签名。二、实验过程：1.学习RSA算法及RSA数字签名算法流程。2. RSA数字签名原理：当发送方想要给接收方发送数据，并想进行数字签名的时候，发送方只需要利用自己的私钥，对数据进行数字签名算法，就可以得到一个新的签名数据，这时发送方需要把自己原来的数据，以及新得到的签名数据都发送给接收方，接收方接受到签名数据之后，用发送方的公钥对签名数据进行验证算法，看得出来的数据与发送方发送过来的数据是不是完全一样的即可。三、实验代码及结果：（1）实验代码：im
RSA”、“数字签名”、“公钥”、“DES”等4个名词的解释
有什么理由不努力
03-20 1822
RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准.RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。RSA公开密钥密码体制。所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制.
加密系列 | SHA加密和解密算法详解&代码示例
挖坑埋你
04-30 8014
import java.security.MessageDigest; /** * 采用SHA加密 * * @author peipei3514 * @datetime 2017-8-11 12:00:34 */ public class SHAUtil { /*** * SHA加密 生成40位SHA码 */ public static String shaEncode(...
【加密】对称加密DES和非对称加密AES、数字签名|非对称加密--公钥和私钥的区别
我的笔记本
04-15 6889
对称加密 1.1定义 指加密和解密使用相同密钥的加密算法，又叫传统密码算法。 就是加密密钥能够从解密密钥中推算出来，同时解密密钥也可以从加密密钥中推算出来。而在大多数的对称算法中，加密密钥和解密密钥是相同的。它要求发送方和接收方在安全通信之前，商定一个密钥。对称算法的安全性依赖于密钥，泄漏密钥就意味着任何人都可以对他们发送或接收的消息解密，所以密钥的保密性对通信的安全性至关重要。 .........
架构师之sha加密解密--------------------------私钥
对酒当歌，人生几何
05-07 455
１．前言． 　　如题． ２．代码． [code="java"] import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; /** * reference apache commons http://commons.apache.org/codec/ * * sup...
DES 强制签名
xmmdbk的博客
10-19 435
https://github.com/hfiref0x/DSEFix DSEFix——hfiref0x
DES、RSA、MD5、SHA、随机生成加密与解密
java漫步天下的专栏
03-02 953
一、数据加密/编码算法列表 常见用于保证安全的加密或编码算法如下： 1、常用密钥算法 密钥算法用来对敏感数据、摘要、签名等信息进行加密，常用的密钥算法包括： DES（Data EncryptionStandard）：数据加密标准，速度较快，适用于加密大量数据的场合；  3DES（TripleDES）：是基于DES，对一块数据用三个不同的密钥进行三次
RSA加密解密及数字签名Java实现
天行健，君子以自强不息；地势坤，君子以厚德载物。
12-01 442
rsa 加密
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值