C#完全实现AES算法加密解密函数

/// <summary>
   /// Aes加密、解密，密钥长度256，密钥长度不大于32个字节
   /// </summary>
   public class AesCryptoHelper
   {
       public const string RET_ERROR = "x07x07x07x07x07";
       private const string CRYPTO_IV = "XIANJIAN";
       private const string CRYPTO_KEY = "XIANJIAN";
       private const int CRYPTO_KEY_LENGTH = 32;
       private const int CRYPTO_IV_LENGTH = 16;
  
       private AesCryptoServiceProvider m_aesCryptoServiceProvider;
       private string m_message;
       public string Message
       {
           get { return m_message; }
           set { m_message = value; }
       }
       private bool m_containKey;
       /// <summary>
       /// True：密文中包含密钥
       /// False：密文中不包含密钥
       /// </summary>
       public bool ContainKey
       {
           get { return m_containKey; }
           set { m_containKey = value; }
       }
       public AesCryptoHelper()
       {
           m_aesCryptoServiceProvider = new AesCryptoServiceProvider();
           m_containKey = true;
           m_message = string.Empty;
       }
       public AesCryptoHelper(bool containKey)
           : this()
       {
           m_containKey = containKey;
       }
       private string Encrypt(string s_crypto, byte[] key, byte[] iv)
       {
           string s_encryped = string.Empty;
           byte[] crypto, encrypted;
           ICryptoTransform ct;
  
           try
           {
               crypto = string2Byte(s_crypto);
               m_aesCryptoServiceProvider.Key = key;
               m_aesCryptoServiceProvider.IV = iv;
               ct = m_aesCryptoServiceProvider.CreateEncryptor();
               encrypted = ct.TransformFinalBlock(crypto, 0, crypto.Length);
               if (m_containKey)
               {
                   s_encryped += byte2HexString(key);
               }
               s_encryped += byte2HexString(encrypted);
               return s_encryped;
           }
           catch (Exception ex)
           {
               m_message = ex.ToString();
               return RET_ERROR;
           }
       }
       /// <summary>
       /// 指定密钥对明文进行AES加密
       /// </summary>
       /// <param name="s_crypto">明文</param>
       /// <param name="s_key">加密密钥</param>
       /// <returns></returns>
       public string Encrypt(string s_crypto, string s_key)
       {
           byte[] key = new byte[CRYPTO_KEY_LENGTH], iv = new byte[CRYPTO_IV_LENGTH];
  
           byte[] temp = string2Byte(s_key);
           if (temp.Length > key.Length)
           {
               m_message = "Key too long,need less than 32 Bytes key.";
               return RET_ERROR;
           }
           key = string2Byte(s_key.PadRight(key.Length));
           iv = string2Byte(CRYPTO_IV.PadRight(iv.Length));
           return Encrypt(s_crypto, key, iv);
       }
       /// <summary>
       /// 动态生成密钥，并对明文进行AES加密
       /// </summary>
       /// <param name="s_crypto">明文</param>
       /// <returns></returns>
       public string Encrypt(string s_crypto)
       {
           byte[] key = new byte[CRYPTO_KEY_LENGTH], iv = new byte[CRYPTO_IV_LENGTH];
  
           m_aesCryptoServiceProvider.GenerateKey();
           key = m_aesCryptoServiceProvider.Key;
           iv = string2Byte(CRYPTO_IV.PadRight(iv.Length));
           return Encrypt(s_crypto, key, iv);
       }
  
       private string Decrypt(string s_encrypted, byte[] key, byte[] iv)
       {
           string s_decrypted = string.Empty;
           byte[] encrypted, decrypted;
           ICryptoTransform ct;
  
           try
           {
               encrypted = hexString2Byte(s_encrypted);
               m_aesCryptoServiceProvider.Key = key;
               m_aesCryptoServiceProvider.IV = iv;
               ct = m_aesCryptoServiceProvider.CreateDecryptor();
               decrypted = ct.TransformFinalBlock(encrypted, 0, encrypted.Length);
               s_decrypted += byte2String(decrypted);
               return s_decrypted;
           }
           catch (Exception ex)
           {
               m_message = ex.ToString();
               m_message = "Decrypt fail.";
               return RET_ERROR;
           }
       }
       /// <summary>
       /// 从密文中解析出密钥，并对密文进行解密
       /// </summary>
       /// <param name="s_encrypted">密文</param>
       /// <returns></returns>
       public string Decrypt(string s_encrypted)
       {
           string s_key = string.Empty;
           byte[] key = new byte[CRYPTO_KEY_LENGTH], iv = new byte[CRYPTO_IV_LENGTH];
  
           if (s_encrypted.Length <= CRYPTO_KEY_LENGTH * 2)
           {
               m_message = "Encrypted string invalid.";
               return RET_ERROR;
           }
           if (m_containKey)
           {
               s_key = s_encrypted.Substring(0, CRYPTO_KEY_LENGTH * 2);
               s_encrypted = s_encrypted.Substring(CRYPTO_KEY_LENGTH * 2);
           }
           key = hexString2Byte(s_key);
           iv = string2Byte(CRYPTO_IV.PadRight(iv.Length));
           return Decrypt(s_encrypted, key, iv);
       }
       /// <summary>
       /// 指定密钥，并对密文进行解密
       /// </summary>
       /// <param name="s_encrypted">密文</param>
       /// <param name="s_key">密钥</param>
       /// <returns></returns>
       public string Decrypt(string s_encrypted, string s_key)
       {
           byte[] key = new byte[CRYPTO_KEY_LENGTH], iv = new byte[CRYPTO_IV_LENGTH];
  
           byte[] temp = string2Byte(s_key);
           if (temp.Length > key.Length)
           {
               m_message = "Key invalid.too long,need less than 32 Bytes";
               return RET_ERROR;
           }
           key = string2Byte(s_key.PadRight(key.Length));
           iv = string2Byte(CRYPTO_IV.PadRight(iv.Length));
           if (m_containKey)
           {
               s_encrypted = s_encrypted.Substring(CRYPTO_KEY_LENGTH * 2);
           }
           return Decrypt(s_encrypted, key, iv);
       }
       private string byte2HexString(byte[] bytes)
       {
           StringBuilder sb = new StringBuilder();
           foreach (byte b in bytes)
           {
               sb.AppendFormat("{0:X2}", b);
           }
           return sb.ToString();
       }
       private byte[] hexString2Byte(string hex)
       {
           int len = hex.Length / 2;
           byte[] bytes = new byte[len];
           for (int i = 0; i < len; i++)
           {
               bytes[i] = (byte)(Convert.ToInt32(hex.Substring(i * 2, 2), 16));
           }
           return bytes;
       }
       private byte[] string2Byte(string str)
       {
           return Encoding.UTF8.GetBytes(str);
       }
       private string byte2String(byte[] bytes)
       {
           return Encoding.UTF8.GetString(bytes);
       }
   }