C# AES256 工具类

public class AES256Utils
    {
        private static byte[] ToByteArray(String hexStr)
        {
            if (string.IsNullOrEmpty(hexStr))
            {
                return new byte[0];
            }

            if (hexStr.StartsWith("0x"))
            {
                hexStr = hexStr.Remove(0, 2);
            }

            var count = hexStr.Length;

            if (count % 2 == 1)
            {
                throw new ArgumentException("Invalid length of bytes:" + count);
            }

            var byteCount = count / 2;
            var result = new byte[byteCount];
            for (int ii = 0; ii < byteCount; ++ii)
            {
                var tempBytes = Byte.Parse(hexStr.Substring(2 * ii, 2), System.Globalization.NumberStyles.HexNumber);
                result[ii] = tempBytes;
            }

            return result;
        }

        /// 16进制数组转字符串
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        private static string ByteArrayToHexString(byte[] bytes, int startIndex, int length)
        {
            if (bytes == null || bytes.Count() < 1)
            {
                return string.Empty;
            }

            var cache = new StringBuilder();

            for (int ii = startIndex; ii < startIndex + length; ++ii)
            {
                var tempHex = Convert.ToString(bytes[ii], 16).ToUpper();
                cache.Append(tempHex.Length == 1 ? "0" + tempHex : tempHex);
            }

            return cache.ToString();
        }

        /// <summary>
        /// AES256加密
        /// </summary>
        /// <param name="encryptStr">32位16进制 明文</param>
        /// <param name="key">64位16进制  密钥</param>
        /// <returns></returns>
        public static string EncryptString(string encryptStr, string key)
        {
            if (string.IsNullOrEmpty(encryptStr) == true || encryptStr.Length != 32)
                return null;

            if (string.IsNullOrEmpty(key) == true || key.Length != 64)
                return null;

            byte[] keyArray = ToByteArray(key);
            byte[] toEncryptArray = ToByteArray(encryptStr);

            RijndaelManaged rDel = new RijndaelManaged();

            rDel.Key = keyArray;
            rDel.Mode = CipherMode.CBC;
            rDel.Padding = PaddingMode.Zeros;

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

            return ByteArrayToHexString(resultArray, 0, resultArray.Length);
        }

        /// <summary>
        /// AES256解密
        /// </summary>
        /// <param name="decryptStr">32位16进制 密文</param>
        /// <param name="key">64位16进制 密钥</param>
        /// <returns></returns>
        /// 
        public static string DecryptString(string decryptStr, string key)
        {
            if (string.IsNullOrEmpty(decryptStr) == true || decryptStr.Length != 32)
                return null;

            if (string.IsNullOrEmpty(key) == true || key.Length != 64)
                return null;

            byte[] keyArray = key.HexStringToByteArray();
            byte[] toEncryptArray = decryptStr.HexStringToByteArray();

            RijndaelManaged rDel = new RijndaelManaged();

            rDel.Key = keyArray;
            rDel.Mode = CipherMode.CBC;
            rDel.Padding = PaddingMode.Zeros;

            ICryptoTransform cTransform = rDel.CreateDecryptor();
            byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return resultArray.ToHexString();
        }

        /// <summary>
        /// AES256解密
        /// </summary>
        /// <param name="decryptStr"16字节 密文</param>
        /// <param name="key">32字节 密钥</param>
        /// <returns></returns>
        public static byte[] DecryptHex(byte[] decryptArray, byte[] iv, byte[] key)
        {
            if (decryptArray == null || decryptArray.Length != 16)
                return null;

            if (key == null || key.Length != 32)
                return null;

            RijndaelManaged rDel = new RijndaelManaged();

            rDel.Key = key;
            rDel.Mode = CipherMode.CBC;
            rDel.Padding = PaddingMode.Zeros;
            
            if(iv != null)
                rDel.IV = iv;

            ICryptoTransform cTransform = rDel.CreateDecryptor();
            byte[] resultArray = cTransform.TransformFinalBlock(decryptArray, 0, decryptArray.Length);

            return resultArray;
        }

        /// <summary>
        /// AES256加密
        /// </summary>
        /// <param name="encryptStr">16字节 明文</param>
        /// <param name="key">16字节 密钥</param>
        /// <returns></returns>
        public static byte[] EncryptHex(byte[] encryptArray, byte[] iv, byte[] key)
        {
            if (encryptArray == null || encryptArray.Length != 16)
                return null;

            if (key == null || key.Length != 32)
                return null;

            RijndaelManaged rDel = new RijndaelManaged();

            rDel.Key = key;
            rDel.Mode = CipherMode.CBC;
            rDel.Padding = PaddingMode.Zeros;

            if (iv != null)
                rDel.IV = iv;

            ICryptoTransform cTransform = rDel.CreateEncryptor();
            byte[] resultArray = cTransform.TransformFinalBlock(encryptArray, 0, encryptArray.Length);

            //String st1 = Utils.ByteArrayToHexString(encryptArray, 0, encryptArray.Length);
            //String st2 = Utils.ByteArrayToHexString(key, 0, key.Length);
            //String st3 = Utils.ByteArrayToHexString(resultArray, 0, resultArray.Length);

            return resultArray;
        }
    }