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 = 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);
    }
}