C# 之 AES加密源码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
 
using Exam.EncryptPrivate;
 
using System.Text;
using System.Security.Cryptography;
 
/// <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 = ;
    private const int CRYPTO_IV_LENGTH = ;
 
    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, , 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, , 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 * )
        {
            m_message = "Encrypted string invalid.";
            return RET_ERROR;
        }
 
        if (m_containKey)
        {
            s_key = s_encrypted.Substring(, CRYPTO_KEY_LENGTH * );
            s_encrypted = s_encrypted.Substring(CRYPTO_KEY_LENGTH * );
        }
 
        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 * );
        }
 
        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 / ;
        byte[] bytes = new byte[len];
 
        for (int i = ; i < len; i++)
        {
            bytes[i] = (byte)(Convert.ToInt32(hex.Substring(i * , ), ));
        }
        return bytes;
    }
 
    private byte[] string2Byte(string str)
    {
        return Encoding.UTF8.GetBytes(str);
    }
 
    private string byte2String(byte[] bytes)
    {
        return Encoding.UTF8.GetString(bytes);
    }
}