AES加密-16进制

项目中用到，此处记下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace CrossSiteLogin.Common
{
    public class AESEncryptHelper
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="toEncryptText">原文</param>
        /// <param name="sKey">密钥</param>
        /// <param name="cipherText">密文</param>
        /// <returns></returns>
        public static bool Encrypt(string toEncryptText, string sKey, ref string cipherText)
        {
            try
            {
                while (sKey.Length < 16)
                {
                    sKey += sKey;
                }
                if (sKey.Length > 16) sKey = sKey.Substring(0, 16);

                byte[] toEncryptData = UTF8Encoding.UTF8.GetBytes(toEncryptText);
                byte[] bKeyData = UTF8Encoding.UTF8.GetBytes(sKey);

                cipherText = ByteToHexStr(AESEncrypt(toEncryptData, bKeyData, bKeyData));
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }

        }
        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="toDecryptText">密文</param>
        /// <param name="sKey">密钥</param>
        /// <param name="originalText">原文</param>
        /// <returns></returns>
        public static bool Decrypt(string toDecryptText, string sKey, ref string originalText)
        {
            try
            {
                while (sKey.Length < 16)
                {
                    sKey += sKey;
                }
                if (sKey.Length > 16) sKey = sKey.Substring(0, 16);

                byte[] toEncryptData = HexStrToByte(toDecryptText);
                byte[] bKeyData = UTF8Encoding.UTF8.GetBytes(sKey);

                originalText = UTF8Encoding.UTF8.GetString(AESDecrypt(toEncryptData, bKeyData, bKeyData));
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        /// <summary>
        /// 字符串转16进制字节数组
        /// </summary>
        /// <param name="hexString"></param>
        /// <returns></returns>
        private static byte[] HexStrToByte(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;
        }
        /// <summary>
        /// 字节数组转16进制字符串
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        private static string ByteToHexStr(byte[] bytes)
        {
            string returnStr = "";
            if (bytes != null)
            {
                for (int i = 0; i < bytes.Length; i++)
                {
                    //returnStr += bytes[i].ToString("X2");
                    returnStr += bytes[i].ToString("x2");
                }
            }
            return returnStr;
        }
        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="Data">被加密的明文</param>
        /// <param name="Key">密钥</param>
        /// <param name="Vector">向量</param>
        /// <returns>密文</returns>
        private static Byte[] AESEncrypt(Byte[] bData, Byte[] bKey, Byte[] bVector)
        {

            Byte[] Cryptograph = null; // 加密后的密文
            Rijndael Aes = Rijndael.Create();
            try
            {
                // 开辟一块内存流
                using (MemoryStream Memory = new MemoryStream())
                {
                    // 把内存流对象包装成加密流对象
                    using (CryptoStream Encryptor = new CryptoStream(Memory,
                    Aes.CreateEncryptor(bKey, bVector),
                    CryptoStreamMode.Write))
                    {
                        // 明文数据写入加密流
                        Encryptor.Write(bData, 0, bData.Length);
                        Encryptor.FlushFinalBlock();

                        Cryptograph = Memory.ToArray();
                    }
                }
            }
            catch
            {
                Cryptograph = null;
            }

            return Cryptograph;
        }
        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="Data">被解密的密文</param>
        /// <param name="Key">密钥</param>
        /// <param name="Vector">向量</param>
        /// <returns>明文</returns>
        private static Byte[] AESDecrypt(Byte[] bData, Byte[] bKey, Byte[] bVector)
        {

            Byte[] original = null; // 解密后的明文

            Rijndael Aes = Rijndael.Create();
            try
            {
                // 开辟一块内存流，存储密文
                using (MemoryStream Memory = new MemoryStream(bData))
                {
                    // 把内存流对象包装成加密流对象
                    using (CryptoStream Decryptor = new CryptoStream(Memory,
                    Aes.CreateDecryptor(bKey, bVector),
                    CryptoStreamMode.Read))
                    {
                        // 明文存储区
                        using (MemoryStream originalMemory = new MemoryStream())
                        {
                            Byte[] Buffer = new Byte[1024];
                            Int32 readBytes = 0;
                            while ((readBytes = Decryptor.Read(Buffer, 0, Buffer.Length)) > 0)
                            {
                                originalMemory.Write(Buffer, 0, readBytes);
                            }

                            original = originalMemory.ToArray();
                        }
                    }
                }
            }
            catch
            {
                original = null;
            }

            return original;
        }
    }
}