AES加密解密

	/// <summary>
    /// ASE加解密
    /// </summary>
    public class AESHelper :  ITransient
    {
        /// <summary>
        /// 秘钥
        /// </summary>
        public static string AesKey;
        /// <summary>
        /// 16位初始向量
        /// </summary>
        public static string AesIV;

        /// <summary>
        /// 将字符串转换成16进制byte数组
        /// </summary>
        /// <param name="aaa">字符串</param>
        /// <returns>生成的数据</returns>
        public static byte[] testconvttetobyte(string aaa)
        {
            byte[] array = new byte[aaa.Length / 2];
            if (aaa.Length == 0)
            {
                return null;
            }
            if ((aaa.Length % 2) != 0)
            {
                return null;
            }
            else
            {
                for (int i = 0; i < aaa.Length / 2; i++)
                {
                    string str = aaa.Substring(i * 2, 2);
                    array[i] = (byte)Convert.ToInt32(str, 16);
                }
            }
            return array;
        }


        /// <summary>
        /// 判断是否够16整除
        /// </summary>
        /// <param name="hexString">要判断的字符串</param>
        /// <returns></returns>
        private static byte[] strToToHexByte(string hexString)
        {

            hexString = hexString.Replace("-", "");
            if ((hexString.Length % 2) != 0)
                hexString += " ";
            byte[] returnBytes = new byte[hexString.Length / 2];
            for (int i = 0; i < returnBytes.Length; i++)
                returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
            return returnBytes;
        }

        public static string tests(string text)
        {
            while (true)
            {
                if (text.Length % 16 != 0)
                {
                    text += "0";
                }
                else
                {
                    break;
                }
            }
            return text;
        }

        /// <summary>  
        /// AES解密  
        /// </summary>  
        /// <param name="inputdata">输入的数据encryptedData</param>  
        /// <returns name="result">解密后的字符串</returns>  
        public static string AESDecrypt(string inputdata)
        {
            try
            {
                AesIV = AesIV.Replace(" ", "+");
                AesKey = AesKey.Replace(" ", "+");
                inputdata = inputdata.Replace(" ", "+");
                //判断是否是16位 如果不够补0
                //text = tests(text);
                //16进制数据转换成byte
                byte[] encryptedData = Convert.FromBase64String(inputdata);  // strToToHexByte(text);
                RijndaelManaged rijndaelCipher = new RijndaelManaged();
                rijndaelCipher.Key = Convert.FromBase64String(AesKey); // Encoding.UTF8.GetBytes(AesKey);
                rijndaelCipher.IV = Convert.FromBase64String(AesIV);// Encoding.UTF8.GetBytes(AesIV);
                rijndaelCipher.Mode = CipherMode.CBC;
                rijndaelCipher.Padding = PaddingMode.PKCS7;
                ICryptoTransform transform = rijndaelCipher.CreateDecryptor();
                byte[] plainText = transform.TransformFinalBlock(encryptedData, 0, encryptedData.Length);
                string result = Encoding.Default.GetString(plainText);
                return result;
            }
            catch (Exception ex)
            {
                string msg = ex.Message.ToString();
                return null;

            }
        }
        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="text">要加密的字符串</param>
        /// <returns>加密后的数据的byte数组</returns>
        public static byte[] AESEncrypt(string text)
        {
            string returnStr = string.Empty;
            try
            {
                //判断是否够16字节整除 不够补0
                text = tests(text);
                RijndaelManaged rijndaelCipher = new RijndaelManaged();
                rijndaelCipher.IV = Encoding.UTF8.GetBytes(AesIV);
                rijndaelCipher.Key = Encoding.UTF8.GetBytes(AesKey);
                rijndaelCipher.Mode = CipherMode.CBC;
                rijndaelCipher.Padding = PaddingMode.None;
                ICryptoTransform transform = rijndaelCipher.CreateEncryptor();
                byte[] plainText = Encoding.UTF8.GetBytes(text);
                byte[] cipherBytes = transform.TransformFinalBlock(plainText, 0, plainText.Length);
                //log4net.Appender.AppenderCollection sss = new log4net.Appender.AppenderCollection();
                return cipherBytes;
            }
            catch (Exception ex)
            {
                ex.ToString();
                return null;
            }
        }

        /// <summary>
        ///  AES 加密
        /// </summary>
        /// <param name="str">明文（待加密）</param>
        /// <param name="key">密钥</param>
        /// <returns></returns>
        public static string AesEncrypt(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            try
            {
                Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);
                RijndaelManaged rm = new RijndaelManaged
                {
                    Key = Encoding.UTF8.GetBytes(key),
                    Mode = CipherMode.ECB,
                    Padding = PaddingMode.PKCS7
                };
                ICryptoTransform cTransform = rm.CreateEncryptor();
                Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

                return Convert.ToBase64String(resultArray, 0, resultArray.Length);
            }
            catch (Exception)
            {
                return str;
            }
        }

        /// <summary>
        ///  AES 解密
        /// </summary>
        /// <param name="str">密文（待解密）</param>
        /// <param name="key">密钥</param>
        /// <returns></returns>
        /// 如果不是正确的密文解密就会失败从而报错影响判断问题的所在，加上判断返回传入的值直接抛出
        public static string AesDecrypt(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            try
            {
                Byte[] toEncryptArray = Convert.FromBase64String(str);
                RijndaelManaged rm = new RijndaelManaged
                {
                    Key = Encoding.UTF8.GetBytes(key),
                    Mode = CipherMode.ECB,
                    Padding = PaddingMode.PKCS7
                };
                ICryptoTransform cTransform = rm.CreateDecryptor();
                Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

                return Encoding.UTF8.GetString(resultArray);
            }
            catch (Exception)
            {
                return str;
            }
        }
    }