一套简单的加密解密思路

加密解密的核心代码：

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

public class AESChiper
{
    /// <summary>
    /// AES加密或者解密
    /// </summary>
    /// <param name="data"></param>
    /// <param name="key"></param>
    /// <param name="isEncrypt"></param>
    /// <returns></returns>
    public byte[] EncryptOrDecrypt(byte[] data, string key, bool isEncrypt)
    {
        if (null == data)
        {
            return null;
        }

        if (data.Length <= 0 || string.IsNullOrEmpty(key))
        {
            return data;
        }

        int keyLen = key.Length;

        RijndaelManaged aes = new RijndaelManaged();
        aes.KeySize = keyLen * 8;
        aes.BlockSize = keyLen * 8;
        aes.Mode = CipherMode.CBC;
        aes.Padding = PaddingMode.Zeros;
        aes.Key = Encoding.UTF8.GetBytes(key);

        aes.IV = new byte[keyLen];
        for (int i = 0; i < keyLen; i++)
        {
            aes.IV[i] = 0;
        }

        var transform = isEncrypt ? aes.CreateEncryptor(aes.Key, aes.IV) : aes.CreateDecryptor();
        byte[] xBuff = null;
        using (var ms = new MemoryStream())
        {
            using (var cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
            {
                cs.Write(data, 0, data.Length);
            }
            xBuff = ms.ToArray();
        }

        return xBuff;
    }
}

定义一个管理类，使得加密解密使用起来更方便，代码如下：

using System;

public class ChiperManager
{
    ChiperManager()
    {

    }

    static ChiperManager _instance;

    public static ChiperManager Instance
    {
        get
        {
            if (null == _instance)
            {
                _instance = new ChiperManager();
            }
            return _instance;
        }
    }

    const string AES_DEFAULT_KEY = "1234567891234567";

    AESChiper mChiper = new AESChiper();

    public byte[] Encrypt(byte[] orgData, string key = AES_DEFAULT_KEY)
    {
        if (null == orgData)
        {
            return null;
        }

        if (orgData.Length <= 0)
        {
            return orgData;
        }

        return mChiper.EncryptOrDecrypt(orgData, key, true);
    }

    public byte[] Decrypt(byte[] encryptData, string key = AES_DEFAULT_KEY)
    {
        if (null == encryptData)
        {
            return null;
        }

        if (encryptData.Length <= 0)
        {
            return encryptData;
        }

        return mChiper.EncryptOrDecrypt(encryptData, key, false);
    }
}

定义一个可以编码解码的类:

class People
{
    public string name;
    public int age;

    public byte[] Encode()
    {
        using (MemoryStream ms = new MemoryStream())
        {
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                bw.Write(name);
                bw.Write(age);

            }
            return ms.ToArray();
        }
    }

    public void Decode(byte[] bytes)
    {
        using (MemoryStream ms = new MemoryStream(bytes))
        {
            using (BinaryReader br = new BinaryReader(ms))
            {
                name = br.ReadString();
                age = br.ReadInt32();
            }
        }
    }

    public override string ToString()
    {
        return $"Name = {name},Age = {age}";
    }
}

加密解密测试：

static void Main(string[] args)
{
    try
    {
        People p = new People();
        p.name = "张三";
        p.age = 20;

        byte[] orgData = p.Encode();

        //加密
        orgData = ChiperManager.Instance.Encrypt(orgData);

        //解密
        orgData = ChiperManager.Instance.Decrypt(orgData);

        //加密后如果不解密，这里将抛出异常
        p.Decode(orgData);

        Console.WriteLine(p);
    }
    catch (Exception e)
    {
        Console.WriteLine(e.Message);
    }

    Console.ReadKey();
}

运行结果：

加密如果不解密，会抛出如下异常: