.Net中对称加密的实现

常见对称加密算法及优缺点

1. DES（Data Encryption Standard）

• 优点：是最早被广泛应用的加密算法，算法公开，实现简单，效率较高。
• 缺点：密钥长度较短（56 位），在现代计算能力下，安全性较低，容易被暴力破解。

2. 3DES（Triple DES）

• 优点：在 DES 的基础上进行了改进，通过多次使用 DES 算法，增加了密钥长度，提高了安全性。
• 缺点：由于多次使用 DES 算法，加密和解密速度相对较慢。

3. AES（Advanced Encryption Standard）

• 优点：是目前应用最广泛的对称加密算法，密钥长度可选（128 位、192 位、256 位），安全性高，加密和解密速度快。
• 缺点：相对来说，算法复杂度较高，实现难度较大。

示例代码

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

class SymmetricEncryption
{
    // DES 加密
    public static string DESEncrypt(string plainText, string key)
    {
        using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
        {
            byte[] inputBytes = Encoding.UTF8.GetBytes(plainText);
            byte[] keyBytes = Encoding.UTF8.GetBytes(key);
            byte[] encryptedBytes;

            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(keyBytes, keyBytes), CryptoStreamMode.Write))
                {
                    cs.Write(inputBytes, 0, inputBytes.Length);
                    cs.FlushFinalBlock();
                    encryptedBytes = ms.ToArray();
                }
            }

            return Convert.ToBase64String(encryptedBytes);
        }
    }

    // DES 解密
    public static string DESDecrypt(string cipherText, string key)
    {
        using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
        {
            byte[] inputBytes = Convert.FromBase64String(cipherText);
            byte[] keyBytes = Encoding.UTF8.GetBytes(key);
            byte[] decryptedBytes;

            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(keyBytes, keyBytes), CryptoStreamMode.Write))
                {
                    cs.Write(inputBytes, 0, inputBytes.Length);
                    cs.FlushFinalBlock();
                    decryptedBytes = ms.ToArray();
                }
            }

            return Encoding.UTF8.GetString(decryptedBytes);
        }
    }

    // 3DES 加密
    public static string TripleDESEncrypt(string plainText, string key)
    {
        using (TripleDESCryptoServiceProvider tripleDes = new TripleDESCryptoServiceProvider())
        {
            byte[] inputBytes = Encoding.UTF8.GetBytes(plainText);
            byte[] keyBytes = Encoding.UTF8.GetBytes(key);
            byte[] encryptedBytes;

            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, tripleDes.CreateEncryptor(keyBytes, keyBytes), CryptoStreamMode.Write))
                {
                    cs.Write(inputBytes, 0, inputBytes.Length);
                    cs.FlushFinalBlock();
                    encryptedBytes = ms.ToArray();
                }
            }

            return Convert.ToBase64String(encryptedBytes);
        }
    }

    // 3DES 解密
    public static string TripleDESDecrypt(string cipherText, string key)
    {
        using (TripleDESCryptoServiceProvider tripleDes = new TripleDESCryptoServiceProvider())
        {
            byte[] inputBytes = Convert.FromBase64String(cipherText);
            byte[] keyBytes = Encoding.UTF8.GetBytes(key);
            byte[] decryptedBytes;

            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, tripleDes.CreateDecryptor(keyBytes, keyBytes), CryptoStreamMode.Write))
                {
                    cs.Write(inputBytes, 0, inputBytes.Length);
                    cs.FlushFinalBlock();
                    decryptedBytes = ms.ToArray();
                }
            }

            return Encoding.UTF8.GetString(decryptedBytes);
        }
    }

    // AES 加密
    public static string AESEncrypt(string plainText, string key)
    {
        using (Aes aesAlg = Aes.Create())
        {
            byte[] inputBytes = Encoding.UTF8.GetBytes(plainText);
            byte[] keyBytes = Encoding.UTF8.GetBytes(key);
            aesAlg.Key = keyBytes;
            aesAlg.GenerateIV();

            byte[] encryptedBytes;

            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV), CryptoStreamMode.Write))
                {
                    cs.Write(inputBytes, 0, inputBytes.Length);
                    cs.FlushFinalBlock();
                    encryptedBytes = ms.ToArray();
                }

                byte[] combinedBytes = new byte[aesAlg.IV.Length + encryptedBytes.Length];
                Array.Copy(aesAlg.IV, 0, combinedBytes, 0, aesAlg.IV.Length);
                Array.Copy(encryptedBytes, 0, combinedBytes, aesAlg.IV.Length, encryptedBytes.Length);

                return Convert.ToBase64String(combinedBytes);
            }
        }
    }

    // AES 解密
    public static string AESDecrypt(string cipherText, string key)
    {
        byte[] combinedBytes = Convert.FromBase64String(cipherText);
        byte[] iv = new byte[16];
        byte[] encryptedBytes = new byte[combinedBytes.Length - iv.Length];

        Array.Copy(combinedBytes, 0, iv, 0, iv.Length);
        Array.Copy(combinedBytes, iv.Length, encryptedBytes, 0, encryptedBytes.Length);

        using (Aes aesAlg = Aes.Create())
        {
            byte[] keyBytes = Encoding.UTF8.GetBytes(key);
            aesAlg.Key = keyBytes;
            aesAlg.IV = iv;

            byte[] decryptedBytes;

            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV), CryptoStreamMode.Write))
                {
                    cs.Write(encryptedBytes, 0, encryptedBytes.Length);
                    cs.FlushFinalBlock();
                    decryptedBytes = ms.ToArray();
                }
            }

            return Encoding.UTF8.GetString(decryptedBytes);
        }
    }

    static void Main()
    {
        string plainText = "Hello, World!";
        string desKey = "abcdefgh"; // DES 密钥长度必须为 8 字节
        string tripleDesKey = "abcdefghijklmnopqrstuvwx"; // 3DES 密钥长度必须为 24 字节
        string aesKey = "abcdefghijklmnop"; // AES 密钥长度可以为 16、24 或 32 字节

        // DES 加密和解密
        string desCipherText = DESEncrypt(plainText, desKey);
        string desDecryptedText = DESDecrypt(desCipherText, desKey);
        Console.WriteLine($"DES 加密结果: {desCipherText}");
        Console.WriteLine($"DES 解密结果: {desDecryptedText}");

        // 3DES 加密和解密
        string tripleDesCipherText = TripleDESEncrypt(plainText, tripleDesKey);
        string tripleDesDecryptedText = TripleDESDecrypt(tripleDesCipherText, tripleDesKey);
        Console.WriteLine($"3DES 加密结果: {tripleDesCipherText}");
        Console.WriteLine($"3DES 解密结果: {tripleDesDecryptedText}");

        // AES 加密和解密
        string aesCipherText = AESEncrypt(plainText, aesKey);
        string aesDecryptedText = AESDecrypt(aesCipherText, aesKey);
        Console.WriteLine($"AES 加密结果: {aesCipherText}");
        Console.WriteLine($"AES 解密结果: {aesDecryptedText}");
    }
}