C#实现AES加密解密

先上代码，注意输出格式

  /// <summary>
        /// AES 加密 输出hex格式
        /// </summary>
        /// <param name="str">明文（待加密）</param>
        /// <param name="key">秘钥</param>
        /// <param name="iv">向量</param>
        /// <returns>加密后的字符串</returns>
        public static string AesEncrypt(string str, string key, string iv)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);

            RijndaelManaged rm = new RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                IV = Encoding.UTF8.GetBytes(iv),
                Mode = CipherMode.CBC,
                Padding = PaddingMode.PKCS7 //加密什么格式对应改为就行，基本的话应该为PKCS7
            };

            ICryptoTransform cTransform = rm.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            //return Convert.ToBase64String(resultArray, 0, resultArray.Length);//返回Base64
            return ByteArrayToHexString(resultArray);
        }

        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="str">需要解密的字符串</param>
        /// <param name="key">32位密钥</param>
        /// <param name="iv">向量（一定要问问对面要用什么向量）</param>
        /// <returns>解密后的字符串</returns>
        public static string Decrypt(string str, string key, string iv)
        {
            byte[] keyArray = Encoding.UTF8.GetBytes(key);
            byte[] toEncryptArray = Convert.FromBase64String(str);
            var rijndael = new RijndaelManaged
            {
                Key = keyArray,
                Mode = CipherMode.CBC,
                Padding = PaddingMode.PKCS7,
                IV = Encoding.UTF8.GetBytes(iv)
            };
            ICryptoTransform cTransform = rijndael.CreateDecryptor();
            byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
            return Encoding.UTF8.GetString(resultArray);
        }

        /// <summary>
        /// 将一个byte数组转换成一个格式化的16进制字符串
        /// </summary>
        /// <param name="data">byte数组</param>
        /// <returns>格式化的16进制字符串</returns>
        public static string ByteArrayToHexString(byte[] data)
        {
            StringBuilder sb = new StringBuilder(data.Length * 3);
            foreach (byte b in data)
            {
                sb.Append(Convert.ToString(b, 16).PadLeft(2, '0'));
            }
            return sb.ToString().ToUpper();
        }

        /// <summary>
        /// 讲16进制字符串转换成byte数组
        /// </summary>
        /// <param name="hexString">16进制字符串</param>
        /// <returns></returns>
        public static byte[] HexStringToByteArray(string hexString)
        {
            var byteArray = new byte[hexString.Length / 2];
            for (var x = 0; x < byteArray.Length; x++)
            {
                var i = Convert.ToInt32(hexString.Substring(x * 2, 2), 16);
                byteArray[x] = (byte)i;
            }
            return byteArray;
        }

带偏移的

        /// <summary>
        /// AES加密 
        /// </summary>
        /// <param name="text">加密字符</param>
        /// <param name="password">加密的密码</param>
        /// <param name="iv">密钥</param>
        /// <returns></returns>
        public string AESEncrypt(string data, string key, string iv, int num)
        {
            RijndaelManaged rijndaelCipher = new RijndaelManaged
            {
                Mode = CipherMode.CBC,
                Padding = PaddingMode.PKCS7,
                KeySize = 128,
                BlockSize = 128,
                Key = Encoding.UTF8.GetBytes(key),
                IV = Encoding.UTF8.GetBytes(iv)
            };

            ICryptoTransform transform = rijndaelCipher.CreateEncryptor();
            byte[] plainText = Encoding.UTF8.GetBytes(data);
            byte[] cipherBytes = transform.TransformFinalBlock(plainText, 0, plainText.Length);

            string a = Convert.ToBase64String(cipherBytes);
            string b = ReplaceA(a.TrimEnd('='));
            return shiftToFront(b, num);

        }

        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="text"></param>
        /// <param name="password"></param>
        /// <param name="iv"></param>
        /// <returns></returns>
        public string AESDecrypt(string data, string key, string iv, int num)
        {
            RijndaelManaged rijndaelCipher = new RijndaelManaged
            {
                Mode = CipherMode.CBC,
                Padding = PaddingMode.PKCS7,
                KeySize = 128,
                BlockSize = 128,
                Key = Encoding.UTF8.GetBytes(key),
                IV = Encoding.UTF8.GetBytes(iv)
            };
            data = shiftToBack(ReplaceB(data), num);
            byte[] encryptedData = null;
            try
            {
                encryptedData = Convert.FromBase64String(data);
            }
            catch(Exception ex)
            {
                try
                {
                    data += "=";
                    encryptedData = Convert.FromBase64String(data);
                }
                catch
                {
                    try
                    {
                        data += "=";
                        encryptedData = Convert.FromBase64String(data);
                    }
                    catch
                    {
                        data += "=";
                        encryptedData = Convert.FromBase64String(data);
                    }
                }
            }

            ICryptoTransform transform = rijndaelCipher.CreateDecryptor();
            byte[] plainText = transform.TransformFinalBlock(encryptedData, 0, encryptedData.Length);

            return Encoding.UTF8.GetString(plainText);
        }

        private static String shiftToBack(String ret, int num)
        {
            if ((num < 1) || (ret == null))
                return ret;

            return ret.Substring(num) + ret.Substring(0, num);
        }

        private static String shiftToFront(String ret, int num)
        {
            if ((num < 1) || (ret == null))
                return ret;

            int index = ret.Length - num;
            if (index < 1)
                return ret;

            return ret.Substring(index) + ret.Substring(0, index);
        }

        public string ReplaceA(string s)
        {
            return s.Replace('+', '-').Replace('/', '_');
        }

        public string ReplaceB(string s)
        {
            return s.Replace('-', '+').Replace('_', '/');
        }