using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace Mall.Common
{
    /// <summary>
    /// 加密帮助类
    /// </summary>
    public class EncryptionHelper
    {
        #region 默认密钥定义
        /// <summary>
        /// 默认加密密钥
        /// </summary>
        public const string DefaultDESKey = @"12345678";
        /// <summary>
        /// 默认加密向量
        /// </summary>
        public const string DefaultDESIV = @"1234567812345678";
        /// <summary>
        /// 默认加密密钥
        /// </summary>
        public const string Default3DESKey = @"123456781234567812345678";
        /// <summary>
        /// 默认加密向量
        /// </summary>
        public const string Default3DESIV = @"1234567812345678";
        /// <summary>
        /// 获取密钥
        /// </summary>
        public const string DefaultAESKey = @"12345678123456781234567812345678";
        /// <summary>
        /// 获取向量
        /// </summary>
        public const string DefaultAESIV = @"1234567812345678";
        /// <summary>
        /// 默认加密密钥
        /// </summary>
        public const string DefaultRC2Key = @"1234567812345678";
        /// <summary>
        /// 默认加密向量
        /// </summary>
        public const string DefaultRC2IV = @"1234567812345678";
        /// <summary>
        /// 默认的RSA公钥
        /// </summary>
        public const string DefaultRSAPublicKey = @"<RSAKeyValue>xxx</RSAKeyValue>";
        /// <summary>
        /// 默认的RSA密钥
        /// </summary>
        public const string DefaultRSAPrivateKey = @"<RSAKeyValue>ccc</RSAKeyValue>";
        #endregion

        #region 对称加密算法

        #region 3DES对称加密算法
        /// <summary>
        /// 使用指定的128字节的密钥对8字节数组进行3Des加密
        /// </summary>
        /// <param name="plainStr"></param>
        /// <param name="key">密钥长度，可以为128（16字节），或是192（24字节）</param>
        /// <param name="iv">加密向量长度64位以上(8个字节以上)</param>
        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns>已加密的字符串</returns>
        public static string TripleDESEncrypt(string plainStr, string key = Default3DESKey, string iv = Default3DESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);
            byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);

            string encrypt = null;
            var tdsc = new TripleDESCryptoServiceProvider();
            try
            {
                //加密模式，偏移
                tdsc.Mode = mode;
                tdsc.Padding = padding;
                using (var mStream = new MemoryStream())
                {
                    using (var cStream = new CryptoStream(mStream, tdsc.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                        if (isBase64Code)
                            encrypt = Convert.ToBase64String(mStream.ToArray());
                        else
                            ConvertHelper.ToString(mStream.ToArray());
                    }
                }
            }
            catch { }
            tdsc.Clear();

            return encrypt;
        }
        /// <summary>
        /// 使用指定的128字节的密钥对8字节数组进行3Des解密
        /// </summary>
        /// <param name="encryptStr"></param>
        /// <param name="key">密钥长度，可以为128（16字节），或是192（24字节）</param>
        /// <param name="iv">加密向量长度64位以上(8个字节以上)</param>
        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns>已解密的字符串</returns>
        public static string TripleDESDecrypt(string encryptStr, string key = Default3DESKey, string iv = Default3DESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);
            byte[] byteArray;
            if (isBase64Code)
                byteArray = Convert.FromBase64String(encryptStr);
            else
                byteArray = ConvertHelper.ToBytes(encryptStr);

            string decrypt = null;
            var tdsc = new TripleDESCryptoServiceProvider();
            try
            {
                tdsc.Mode = mode;
                tdsc.Padding = padding;
                using (var mStream = new MemoryStream())
                {
                    using (var cStream = new CryptoStream(mStream, tdsc.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                        decrypt = Encoding.UTF8.GetString(mStream.ToArray());
                    }
                }
            }
            catch { }
            tdsc.Clear();

            return decrypt;
        }
        #endregion

        #region DES对称加密算法
        /// <summary>
        /// DES加密
        /// </summary>
        /// <param name="plainStr">明文字符串</param>
        /// <param name="key">加密密钥长度64位(8字节)</param>
        /// <param name="iv">加密向量长度64位以上(8个字节以上)</param>
        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns>密文</returns>
        public static string DESEncrypt(string plainStr, string key = DefaultDESKey, string iv = DefaultDESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);
            byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);

            string encrypt = null;
            var des = new DESCryptoServiceProvider();
            try
            {
                des.Mode = mode;
                des.Padding = padding;
                using (var mStream = new MemoryStream())
                {
                    using (var cStream = new CryptoStream(mStream, des.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                        if (isBase64Code)
                            encrypt = Convert.ToBase64String(mStream.ToArray());
                        else
                            ConvertHelper.ToString(mStream.ToArray());
                    }
                }
            }
            catch { }
            des.Clear();

            return encrypt;
        }

        /// <summary>
        /// DES解密
        /// </summary>
        /// <param name="encryptStr">密文字符串</param>
        /// <param name="key">加密密钥长度64位(8字节)</param>
        /// <param name="iv">加密向量长度64位以上(8个字节以上)</param>
        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns>明文</returns>
        public static string DESDecrypt(string encryptStr, string key = DefaultDESKey, string iv = DefaultDESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);
            byte[] byteArray;
            if (isBase64Code)
                byteArray = Convert.FromBase64String(encryptStr);
            else
                byteArray = ConvertHelper.ToBytes(encryptStr);

            string decrypt = null;
            var des = new DESCryptoServiceProvider();
            try
            {
                des.Mode = mode;
                des.Padding = padding;
                using (var mStream = new MemoryStream())
                {
                    using (var cStream = new CryptoStream(mStream, des.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                        decrypt = Encoding.UTF8.GetString(mStream.ToArray());
                    }
                }
            }
            catch { }
            des.Clear();

            return decrypt;
        }
        #endregion

        #region AES加密算法
        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="plainStr">明文字符串</param>
        /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
        /// <param name="iv">加密向量(16到19字节)</param>
        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns>密文</returns>
        public static string AESEncrypt(string plainStr, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);
            byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);

            var encrypts = AESEncrypt(byteArray, key, iv, mode, padding);
            if (isBase64Code)
                return Convert.ToBase64String(encrypts);
            else
                return ConvertHelper.ToString(encrypts);
        }

        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="plainbytes">明文字节数组</param>
        /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
        /// <param name="iv">加密向量(16到19字节)</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns></returns>
        public static byte[] AESEncrypt(byte[] plainbytes, string key = DefaultAESKey, string iv = DefaultAESIV, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);
            byte[] byteArray = plainbytes;

            byte[] encrypt = null;
            var aes = Rijndael.Create();
            try
            {
                aes.Padding = padding;
                aes.Mode = mode;
                using (var mStream = new MemoryStream())
                {
                    using (var cStream = new CryptoStream(mStream, aes.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                    }
                    encrypt = mStream.ToArray();
                }
            }
            catch { }
            aes.Clear();

            return encrypt;
        }
        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="plainbytes">明文字节数组</param>
        /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
        /// <param name="iv">加密向量(16到19字节)</param>
        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns>密文</returns>
        public static string AESEncrypt(byte[] plainbytes, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);

            var encrypts = AESEncrypt(plainbytes, key, iv, mode, padding);
            if (isBase64Code)
                return Convert.ToBase64String(encrypts);
            else
                return ConvertHelper.ToString(encrypts);
        }
        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="encryptStr">密文字符串</param>
        /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
        /// <param name="iv">加密向量(16到19字节)</param>
        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns>明文</returns>
        public static string AESDecrypt(string encryptStr, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);
            byte[] byteArray;
            if (isBase64Code)
                byteArray = Convert.FromBase64String(encryptStr);
            else
                byteArray = ConvertHelper.ToBytes(encryptStr);

            string decrypt = null;
            var aes = Rijndael.Create();
            try
            {
                aes.Mode = mode;
                aes.Padding = padding;
                using (var mStream = new MemoryStream())
                {
                    using (var cStream = new CryptoStream(mStream, aes.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                        decrypt = Encoding.UTF8.GetString(mStream.ToArray());
                    }
                }
            }
            catch { }
            aes.Clear();

            return decrypt;
        }
        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="encryptStr">密文字符串</param>
        /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
        /// <param name="iv">加密向量(16到19字节)</param>
        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns>明文</returns>
        public static byte[] AESDecryptToBytes(string encryptStr, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);
            byte[] byteArray;
            if (isBase64Code)
                byteArray = Convert.FromBase64String(encryptStr);
            else
                byteArray = ConvertHelper.ToBytes(encryptStr);

            byte[] decrypt = null;
            var aes = Rijndael.Create();
            try
            {
                aes.Mode = mode;
                aes.Padding = padding;
                using (var mStream = new MemoryStream())
                {
                    using (var cStream = new CryptoStream(mStream, aes.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                    }
                    decrypt = mStream.ToArray();
                }
            }
            catch { }
            aes.Clear();

            return decrypt;
        }
        #endregion

        #region RC2加密算法
        /// <summary>
        /// RC2加密
        /// </summary>
        /// <param name="plainStr">明文字符串</param>
        /// <param name="key">加密密钥支持40~128长度，可以每8位递增（5到16个长度的字符串）</param>
        /// <param name="iv">加密向量64位以上（8个字节上去字符串）</param>
        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns>密文</returns>
        public static string RC2Encrypt(string plainStr, string key = DefaultRC2Key, string iv = DefaultRC2IV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);
            byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);

            string encrypt = null;
            var rc2 = new RC2CryptoServiceProvider();
            try
            {
                rc2.Padding = padding;
                rc2.Mode = mode;
                using (var mStream = new MemoryStream())
                {
                    using (var cStream = new CryptoStream(mStream, rc2.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                        if (isBase64Code)
                            encrypt = Convert.ToBase64String(mStream.ToArray());
                        else
                            encrypt = ConvertHelper.ToString(mStream.ToArray());
                    }
                }
            }
            catch { }
            rc2.Clear();

            return encrypt;
        }

        /// <summary>
        /// RC2解密
        /// </summary>
        /// <param name="encryptStr">明文字符串</param>
        /// <param name="key">加密密钥支持40~128长度，可以每8位递增（5到16个长度的字符串）</param>
        /// <param name="iv">加密向量64位以上（8个字节上去字符串）</param>
        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充模式</param>
        /// <returns>明文</returns>
        public static string RC2Decrypt(string encryptStr, string key = DefaultRC2Key, string iv = DefaultRC2IV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
        {
            byte[] bKey = Encoding.UTF8.GetBytes(key);
            byte[] bIV = Encoding.UTF8.GetBytes(iv);
            byte[] byteArray;
            if (isBase64Code)
                byteArray = Convert.FromBase64String(encryptStr);
            else
                byteArray = ConvertHelper.ToBytes(encryptStr);

            string decrypt = null;
            var rc2 = new RC2CryptoServiceProvider();
            try
            {
                rc2.Mode = mode;
                rc2.Padding = padding;
                using (var mStream = new MemoryStream())
                {
                    using (var cStream = new CryptoStream(mStream, rc2.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                        decrypt = Encoding.UTF8.GetString(mStream.ToArray());
                    }
                }
            }
            catch { }
            rc2.Clear();

            return decrypt;
        }
        #endregion

        #endregion

        #region 哈稀算法

        #region 获取哈稀散列值
        /// <summary>
        /// 使用md5计算散列
        /// </summary>
        /// <param name="source">要用MD5算散列的字节数据</param>
        /// <returns>经过MD5算散列后的数据</returns>
        public static byte[] Hash(byte[] source)
        {
            if ((source == null) || (source.Length == 0)) throw new ArgumentException("source is not valid");
            var m = MD5.Create();
            return m.ComputeHash(source);
        }
        /// <summary>
        /// 对传入的明文密码进行Hash加密,密码不能为中文
        /// </summary>
        /// <param name="oriPassword">需要加密的明文密码</param>
        /// <returns>经过Hash加密的密码</returns>
        public static string HashPassword(string oriPassword)
        {
            if (string.IsNullOrEmpty(oriPassword))
                throw new ArgumentException("oriPassword is valid");

            var acii = new ASCIIEncoding();
            var hashedBytes = Hash(acii.GetBytes(oriPassword));
            return ConvertHelper.ToString(hashedBytes);
        }
        /// <summary>
        /// 计算MD5
        /// </summary>
        /// <param name="data">要算MD5的字符串</param>
        /// <param name="isBase64Code">是否是Base64编码</param>
        /// <returns>MD5字符串</returns>
        public static string HashMD5(string data, bool isBase64Code = false)
        {
            if (string.IsNullOrEmpty(data)) return "";
            var md5 = new MD5CryptoServiceProvider();
            byte[] bytes = Encoding.UTF8.GetBytes(data);
            bytes = md5.ComputeHash(bytes);
            md5.Clear();
            if (isBase64Code)
                return Convert.ToBase64String(bytes);
            else
                return ConvertHelper.ToString(bytes);
        }
        /// <summary>
        /// 生成16位的MD5散列值
        /// </summary>
        /// <param name="data">要算MD5的字符串</param>
        /// <returns></returns>
        public static string HashMD516(string data)
        {
            var md5 = new MD5CryptoServiceProvider();
            byte[] bytes = Encoding.UTF8.GetBytes(data);
            return ConvertHelper.ToString(md5.ComputeHash(bytes)).Substring(8, 16);
        }

        /// <summary>
        /// 对字符串进行SHA1散列
        /// </summary>
        /// <param name="data">需要哈稀的字符串</param>
        /// <param name="isBase64"></param>
        /// <returns>密文</returns>
        public static string HashSHA1(string data, bool isBase64 = false)
        {
            var StrRes = Encoding.UTF8.GetBytes(data);
            HashAlgorithm iSHA = new SHA1CryptoServiceProvider();
            StrRes = iSHA.ComputeHash(StrRes);
            if (isBase64)
                return Convert.ToBase64String(StrRes);
            else
                return ConvertHelper.ToString(StrRes);
        }

        /// <summary>
        /// SHA256加密，不可逆转
        /// </summary>
        /// <param name="data">string data:被加密的字符串</param>
        /// <param name="isBase64"></param>
        /// <returns>返回加密后的字符串</returns>
        public static string HashSHA256(string data, bool isBase64 = false)
        {
            SHA256 s256 = new SHA256CryptoServiceProvider();
            byte[] byte1 = Encoding.UTF8.GetBytes(data);
            byte1 = s256.ComputeHash(byte1);
            s256.Clear();
            if (isBase64)
                return Convert.ToBase64String(byte1);
            else
                return ConvertHelper.ToString(byte1);
        }

        /// <summary>
        /// SHA384加密，不可逆转
        /// </summary>
        /// <param name="data">string data:被加密的字符串</param>
        /// <param name="isBase64"></param>
        /// <returns>返回加密后的字符串</returns>
        public static string HashSHA384(string data, bool isBase64 = false)
        {
            SHA384 s384 = new SHA384CryptoServiceProvider();
            byte[] byte1 = Encoding.UTF8.GetBytes(data);
            byte1 = s384.ComputeHash(byte1);
            s384.Clear();
            if (isBase64)
                return Convert.ToBase64String(byte1);
            else
                return ConvertHelper.ToString(byte1);
        }

        /// <summary>
        /// SHA512加密，不可逆转
        /// </summary>
        /// <param name="data">string data:被加密的字符串</param>
        /// <param name="isBase64"></param>
        /// <returns>返回加密后的字符串</returns>
        public static string HashSHA512(string data, bool isBase64 = false)
        {
            SHA512 s512 = new SHA512CryptoServiceProvider();
            byte[] byte1 = Encoding.Default.GetBytes(data);
            byte1 = s512.ComputeHash(byte1);
            s512.Clear();
            if (isBase64)
                return Convert.ToBase64String(byte1);
            else
                return ConvertHelper.ToString(byte1);
        }
        #endregion

        #region 带混淆字符串的散列
        /// <summary>
        /// 对字符串进行HmacMD5散列
        /// </summary>
        /// <param name="key">密钥</param>
        /// <param name="data">需要哈稀的字符串</param>
        /// <param name="isBase64"></param>
        /// <returns>密文</returns>
        public static string HmacMD5(string key, string data, bool isBase64 = false)
        {
            var StrRes = Encoding.UTF8.GetBytes(data);
            var bkey = Encoding.UTF8.GetBytes(key);
            var hmacSha1 = new HMACMD5(bkey);
            StrRes = hmacSha1.ComputeHash(StrRes);
            if (isBase64)
                return Convert.ToBase64String(StrRes);
            else
                return ConvertHelper.ToString(StrRes);
        }

        /// <summary>
        /// 对字符串进行HmacSHA1散列
        /// </summary>
        /// <param name="key">密钥</param>
        /// <param name="data">需要哈稀的字符串</param>
        /// <param name="isBase64"></param>
        /// <returns>密文</returns>
        public static string HmacSHA1(string key, string data, bool isBase64 = false)
        {
            var StrRes = Encoding.UTF8.GetBytes(data);
            var bkey = Encoding.UTF8.GetBytes(key);
            HMACSHA1 hmacSha1 = new HMACSHA1(bkey);
            StrRes = hmacSha1.ComputeHash(StrRes);
            if (isBase64)
                return Convert.ToBase64String(StrRes);
            else
                return ConvertHelper.ToString(StrRes);
        }

        /// <summary>
        /// 对字符串进行HmacSHA256散列
        /// </summary>
        /// <param name="key">密钥</param>
        /// <param name="data">需要哈稀的字符串</param>
        /// <param name="isBase64"></param>
        /// <returns>密文</returns>
        public static string HmacSHA256(string key, string data, bool isBase64 = false)
        {
            var StrRes = Encoding.UTF8.GetBytes(data);
            var bkey = Encoding.UTF8.GetBytes(key);
            var hmacSha1 = new HMACSHA256(bkey);
            StrRes = hmacSha1.ComputeHash(StrRes);
            if (isBase64)
                return Convert.ToBase64String(StrRes);
            else
                return ConvertHelper.ToString(StrRes);
        }

        /// <summary>
        /// 对字符串进行HmacSHA384散列
        /// </summary>
        /// <param name="key">密钥</param>
        /// <param name="data">需要哈稀的字符串</param>
        /// <param name="isBase64"></param>
        /// <returns>密文</returns>
        public static string HmacSHA384(string key, string data, bool isBase64 = false)
        {
            var StrRes = Encoding.UTF8.GetBytes(data);
            var bkey = Encoding.UTF8.GetBytes(key);
            var hmacSha1 = new HMACSHA384(bkey);
            StrRes = hmacSha1.ComputeHash(StrRes);
            if (isBase64)
                return Convert.ToBase64String(StrRes);
            else
                return ConvertHelper.ToString(StrRes);
        }

        /// <summary>
        /// 对字符串进行HmacSHA512散列
        /// </summary>
        /// <param name="key">密钥</param>
        /// <param name="data">需要哈稀的字符串</param>
        /// <param name="isBase64"></param>
        /// <returns>密文</returns>
        public static string HmacSHA512(string key, string data, bool isBase64 = false)
        {
            var StrRes = Encoding.UTF8.GetBytes(data);
            var bkey = Encoding.UTF8.GetBytes(key);
            var hmacSha1 = new HMACSHA512(bkey);
            StrRes = hmacSha1.ComputeHash(StrRes);
            if (isBase64)
                return Convert.ToBase64String(StrRes);
            else
                return ConvertHelper.ToString(StrRes);
        }
        #endregion

        #endregion

        #region 非对称加密算法
        /// <summary>
        /// RSA加密
        /// </summary>
        /// <param name="plaintData">明文</param>
        /// <param name="publicKey">RSA公钥</param>
        /// <param name="isBase64">输出数据是否用Base64编码</param>
        /// <returns></returns>
        public static string RSAEncrypt(string plaintData, string publicKey = DefaultRSAPublicKey, bool isBase64 = false)
        {
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(publicKey);
            var cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(plaintData), false);
            if (isBase64)
                return Convert.ToBase64String(cipherbytes);
            else
                return ConvertHelper.ToString(cipherbytes);
        }
        /// <summary>
        /// RSA解密
        /// </summary>
        /// <param name="encryptData">密文</param>
        /// <param name="privateKey">RSA私钥</param>
        /// <param name="isBase64">密文数据是否用Base64编码</param>
        /// <returns></returns>
        public static string RSADecrypt(string encryptData, string privateKey = DefaultRSAPublicKey, bool isBase64 = false)
        {
            byte[] bData;
            if (isBase64)
                bData = Convert.FromBase64String(encryptData);
            else
                bData = ConvertHelper.ToBytes(encryptData);
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(privateKey);
            var cipherbytes = rsa.Decrypt(bData, false);
            return Encoding.UTF8.GetString(cipherbytes);
        }
        /// <summary>
        /// RSA加密
        /// </summary>
        /// <param name="plaintData">明文</param>
        /// <param name="publicKey">RSA公钥</param>
        /// <param name="isBase64">输出数据是否用Base64编码</param>
        /// <returns></returns>
        public static string RSAEncrypt(string plaintData, RSAParameters publicKey, bool isBase64 = false)
        {
            var rsa = new RSACryptoServiceProvider();
            rsa.ImportParameters(publicKey);
            var cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(plaintData), false);
            if (isBase64)
                return Convert.ToBase64String(cipherbytes);
            else
                return ConvertHelper.ToString(cipherbytes);
        }
        /// <summary>
        /// RSA解密
        /// </summary>
        /// <param name="encryptData">密文</param>
        /// <param name="privateKey">RSA私钥</param>
        /// <param name="isBase64">密文数据是否用Base64编码</param>
        /// <returns></returns>
        public static string RSADecrypt(string encryptData, RSAParameters privateKey, bool isBase64 = false)
        {
            byte[] bData;
            if (isBase64)
                bData = Convert.FromBase64String(encryptData);
            else
                bData = ConvertHelper.ToBytes(encryptData);
            var rsa = new RSACryptoServiceProvider();
            rsa.ImportParameters(privateKey);
            var cipherbytes = rsa.Decrypt(bData, false);
            return Encoding.UTF8.GetString(cipherbytes);
        }
        #endregion

        /// <summary>
        /// 解析手机号码
        /// </summary>
        /// <param name="encryptedDataStr"></param>
        /// <param name="key"></param>
        /// <param name="iv"></param>
        /// <returns></returns>

        public static string AES_decrypt(string encryptedDataStr, string key, string iv)
        {
            RijndaelManaged rijalg = new RijndaelManaged();
            //-----------------    
            //设置 cipher 格式 AES-128-CBC    
            rijalg.KeySize = 128;
            rijalg.Padding = PaddingMode.PKCS7;
            rijalg.Mode = CipherMode.CBC;
            rijalg.Key = Convert.FromBase64String(key);
            rijalg.IV = Convert.FromBase64String(iv);
            byte[] encryptedData = Convert.FromBase64String(encryptedDataStr);
            //解密    
            ICryptoTransform decryptor = rijalg.CreateDecryptor(rijalg.Key, rijalg.IV);
            string result;
            using (MemoryStream msDecrypt = new MemoryStream(encryptedData))
            {
                using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                    {
                        result = srDecrypt.ReadToEnd();
                    }
                }
            }
            return result;
        }
    }

    /// <summary>
    /// RSA加解密类
    /// </summary>
    public class RSACryptionHelper
    {
        #region RSA 加密解密 

        #region RSA 的密钥产生 
        /// <summary>
        /// RSA 的密钥产生 产生私钥 和公钥 
        /// </summary>
        /// <param name="xmlKeys"></param>
        /// <param name="xmlPublicKey"></param>
        public void RSAKey(out string xmlKeys, out string xmlPublicKey)
        {
            var rsa = new RSACryptoServiceProvider();
            xmlKeys = rsa.ToXmlString(true);
            xmlPublicKey = rsa.ToXmlString(false);
        }
        #endregion

        #region RSA的加密函数 
        //############################################################################## 
        //RSA 方式加密 
        //说明KEY必须是XML的行式,返回的是字符串 
        //在有一点需要说明！！该加密方式有 长度 限制的！！ 
        //############################################################################## 

        //RSA的加密函数  string
        /// <summary>
        /// RSA加密
        /// </summary>
        /// <param name="xmlPublicKey"></param>
        /// <param name="m_strEncryptString"></param>
        /// <returns></returns>
        public string RSAEncrypt(string xmlPublicKey, string m_strEncryptString)
        {

            byte[] PlainTextBArray;
            byte[] CypherTextBArray;
            string Result;
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(xmlPublicKey);
            PlainTextBArray = (new UnicodeEncoding()).GetBytes(m_strEncryptString);
            CypherTextBArray = rsa.Encrypt(PlainTextBArray, false);
            Result = Convert.ToBase64String(CypherTextBArray);
            return Result;

        }
        //RSA的加密函数 byte[]
        /// <summary>
        /// RSA解密
        /// </summary>
        /// <param name="xmlPublicKey"></param>
        /// <param name="EncryptString"></param>
        /// <returns></returns>
        public string RSAEncrypt(string xmlPublicKey, byte[] EncryptString)
        {

            byte[] CypherTextBArray;
            string Result;
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(xmlPublicKey);
            CypherTextBArray = rsa.Encrypt(EncryptString, false);
            Result = Convert.ToBase64String(CypherTextBArray);
            return Result;

        }
        #endregion

        #region RSA的解密函数 
        /// <summary>
        /// RSA的解密函数  string
        /// </summary>
        /// <param name="xmlPrivateKey"></param>
        /// <param name="m_strDecryptString"></param>
        /// <returns></returns>
        public string RSADecrypt(string xmlPrivateKey, string m_strDecryptString)
        {
            byte[] PlainTextBArray;
            byte[] DypherTextBArray;
            string Result;
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(xmlPrivateKey);
            PlainTextBArray = Convert.FromBase64String(m_strDecryptString);
            DypherTextBArray = rsa.Decrypt(PlainTextBArray, false);
            Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
            return Result;

        }

        /// <summary>
        /// RSA的解密函数  byte
        /// </summary>
        /// <param name="xmlPrivateKey"></param>
        /// <param name="DecryptString"></param>
        /// <returns></returns>
        public string RSADecrypt(string xmlPrivateKey, byte[] DecryptString)
        {
            byte[] DypherTextBArray;
            string Result;
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(xmlPrivateKey);
            DypherTextBArray = rsa.Decrypt(DecryptString, false);
            Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
            return Result;

        }
        #endregion

        #endregion

        #region RSA 数字签名 

        #region 获取Hash描述表
        /// <summary>
        /// 获取Hash描述表
        /// </summary>
        /// <param name="m_strSource"></param>
        /// <param name="HashData"></param>
        /// <returns></returns>
        public bool GetHash(string m_strSource, ref byte[] HashData)
        {
            //从字符串中取得Hash描述 
            byte[] Buffer;
            var MD5 = HashAlgorithm.Create("MD5");
            Buffer = Encoding.UTF8.GetBytes(m_strSource);
            HashData = MD5.ComputeHash(Buffer);

            return true;
        }

        /// <summary>
        /// 获取Hash描述表
        /// </summary>
        /// <param name="m_strSource"></param>
        /// <param name="strHashData"></param>
        /// <returns></returns>
        public bool GetHash(string m_strSource, ref string strHashData)
        {
            //从字符串中取得Hash描述 
            byte[] Buffer;
            byte[] HashData;
            var MD5 = HashAlgorithm.Create("MD5");
            Buffer = Encoding.UTF8.GetBytes(m_strSource);
            HashData = MD5.ComputeHash(Buffer);

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

        }

        /// <summary>
        /// 获取Hash描述表
        /// </summary>
        /// <param name="objFile"></param>
        /// <param name="HashData"></param>
        /// <returns></returns>
        public bool GetHash(FileStream objFile, ref byte[] HashData)
        {
            //从文件中取得Hash描述 
            var MD5 = HashAlgorithm.Create("MD5");
            HashData = MD5.ComputeHash(objFile);
            objFile.Close();

            return true;

        }

        /// <summary>
        /// 获取Hash描述表
        /// </summary>
        /// <param name="objFile"></param>
        /// <param name="strHashData"></param>
        /// <returns></returns>
        public bool GetHash(FileStream objFile, ref string strHashData)
        {
            //从文件中取得Hash描述 
            byte[] HashData;
            var MD5 = HashAlgorithm.Create("MD5");
            HashData = MD5.ComputeHash(objFile);
            objFile.Close();

            strHashData = Convert.ToBase64String(HashData);

            return true;
        }
        #endregion

        #region RSA 签名
        /// <summary>
        /// RSA 签名
        /// </summary>
        /// <param name="privateKey">Xml私钥</param>
        /// <param name="hashData">待签名Hash描述</param>
        /// <param name="signatureData">签名后的结果</param>
        /// <returns></returns>
        public bool Signature(string privateKey, byte[] hashData, ref byte[] signatureData)
        {
            try
            {
                var RSA = new RSACryptoServiceProvider();
                RSA.FromXmlString(privateKey);
                var RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
                //设置签名的算法为MD5 
                RSAFormatter.SetHashAlgorithm("MD5");
                //执行签名 
                signatureData = RSAFormatter.CreateSignature(hashData);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// RSA 签名
        /// </summary>
        /// <param name="privateKey">Xml私钥</param>
        /// <param name="hashData">待签名Hash描述</param>
        /// <param name="signatureData">签名后的结果</param>
        /// <returns></returns>
        public bool Signature(string privateKey, byte[] hashData, ref string signatureData)
        {
            try
            {
                var RSA = new RSACryptoServiceProvider();
                RSA.FromXmlString(privateKey);
                var RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
                //设置签名的算法为MD5 
                RSAFormatter.SetHashAlgorithm("MD5");
                //执行签名 
                signatureData = Convert.ToBase64String(RSAFormatter.CreateSignature(hashData));
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// RSA 签名
        /// </summary>
        /// <param name="privateKey">Xml私钥</param>
        /// <param name="hashData">待签名Hash描述</param>
        /// <param name="signatureData">签名后的结果</param>
        /// <returns></returns>
        public bool Signature(string privateKey, string hashData, ref byte[] signatureData)
        {
            try
            {
                var RSA = new RSACryptoServiceProvider();
                RSA.FromXmlString(privateKey);
                var RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
                //设置签名的算法为MD5 
                RSAFormatter.SetHashAlgorithm("MD5");
                //执行签名 
                var bHashData = Convert.FromBase64String(hashData);
                signatureData = RSAFormatter.CreateSignature(bHashData);

                return true;
            }
            catch { return false; }
        }

        /// <summary>
        /// RSA 签名
        /// </summary>
        /// <param name="privateKey">Xml私钥</param>
        /// <param name="hashData">待签名Hash描述</param>
        /// <param name="signatureData">签名后的结果</param>
        /// <returns></returns>
        public bool Signature(string privateKey, string hashData, ref string signatureData)
        {
            try
            {
                var RSA = new RSACryptoServiceProvider();
                RSA.FromXmlString(privateKey);
                var RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
                //设置签名的算法为MD5 
                RSAFormatter.SetHashAlgorithm("MD5");
                //执行签名 
                var bHashData = Convert.FromBase64String(hashData);
                signatureData = Convert.ToBase64String(RSAFormatter.CreateSignature(bHashData));
                return true;
            }
            catch { return false; }
        }
        #endregion

        #region RSA 签名验证 
        /// <summary>
        /// RSA签名验证（验证时，函数RSADeformatter.VerifySignature先用公钥解密signatureData）
        /// </summary>
        /// <param name="publicKey">Xml字符串公钥</param>
        /// <param name="hashData">Hash描述(刚生成的报文摘要)</param>
        /// <param name="signatureData">签名后的结果(等待验证的私钥加密的Hash描述)</param>
        /// <returns></returns>
        public bool VerifySignature(string publicKey, byte[] hashData, byte[] signatureData)
        {
            var RSA = new RSACryptoServiceProvider();
            RSA.FromXmlString(publicKey);
            var RSADeformatter = new RSAPKCS1SignatureDeformatter(RSA);
            //指定解密的时候HASH算法为MD5 
            RSADeformatter.SetHashAlgorithm("MD5");
            return (RSADeformatter.VerifySignature(hashData, signatureData));
        }
        /// <summary>
        /// RSA签名验证（验证时，函数RSADeformatter.VerifySignature先用公钥解密signatureData）
        /// </summary>
        /// <param name="publicKey">Xml字符串公钥</param>
        /// <param name="hashData">Hash描述(刚生成的报文摘要)</param>
        /// <param name="signatureData">签名后的结果(等待验证的私钥加密的Hash描述)</param>
        /// <returns></returns>
        public bool VerifySignature(string publicKey, string hashData, byte[] signatureData)
        {
            byte[] bHashData = Convert.FromBase64String(hashData);
            return VerifySignature(publicKey, bHashData, signatureData);
        }
        /// <summary>
        /// RSA签名验证（验证时，函数RSADeformatter.VerifySignature先用公钥解密signatureData）
        /// </summary>
        /// <param name="publicKey">Xml字符串公钥</param>
        /// <param name="hashData">Hash描述(刚生成的报文摘要)</param>
        /// <param name="signatureData">签名后的结果(等待验证的私钥加密的Hash描述)</param>
        /// <returns></returns>
        public bool VerifySignature(string publicKey, byte[] hashData, string signatureData)
        {
            var bSignatureData = Convert.FromBase64String(signatureData);
            return VerifySignature(publicKey, hashData, bSignatureData);
        }
        /// <summary>
        /// RSA签名验证（验证时，函数RSADeformatter.VerifySignature先用公钥解密signatureData）
        /// </summary>
        /// <param name="publicKey">Xml字符串公钥</param>
        /// <param name="hashData">Hash描述(刚生成的报文摘要)</param>
        /// <param name="signatureData">签名后的结果(等待验证的私钥加密的Hash描述)</param>
        /// <returns></returns>
        public bool VerifySignature(string publicKey, string hashData, string signatureData)
        {
            var bHashData = Convert.FromBase64String(hashData);
            var bSignatureData = Convert.FromBase64String(signatureData);
            return VerifySignature(publicKey, bHashData, bSignatureData);
        }
        #endregion

        #endregion

    }
}
