C# 中加密解密算法

一、加密算法核心分类及特性

加密算法按原理可分为三大类，核心区别体现在密钥使用方式 和可逆性上：

分类	核心特性	代表算法	用途
对称加密	加密和解密使用相同密钥；速度快，适合大量数据；密钥管理难度高（需安全传递）	AES、DES	文件加密、数据传输（如 API 通信加密）
非对称加密	使用公钥 - 私钥对（公钥加密，私钥解密）；安全性高，速度慢，适合小数据；密钥管理简单	RSA	数字签名、密钥交换（如 HTTPS 证书验证）
散列算法	不可逆（无法从密文还原明文）；将任意长度数据转为固定长度哈希值；用于校验数据完整性	MD5、SHA 系列（SHA-256 等）	密码存储、文件校验（如判断文件是否被篡改）

二、各类算法详解及代码实现分析

1. 对称加密算法

核心逻辑 ：通过相同的密钥和初始化向量（IV）对数据进行加密和解密，依赖CryptoStream处理流数据。

（1）AES 算法（Advanced Encryption Standard）

• 特点：替代 DES 的新一代标准，支持 128/192/256 位密钥（常用 128 位），安全性高，速度快。

• 关键要求：密钥（Key）和初始化向量（IV）长度必须为 16 字节（128 位）。

• 代码实现（AESHelper）：

  // 加密流程：创建AES实例 → 配置Key和IV → 创建加密器 → 通过CryptoStream写入明文 → 转Base64
  // 解密流程：反向操作，通过CryptoStream读取密文 → 转明文

  注：Key和IV

  通常从配置文件读取（如示例中ConfigurationManager.AppSettings），需确保长度为 16 字节。

（2）DES 算法（Data Encryption Standard）

• 特点：早期标准，密钥长度 56 位（实际实现中含 8 位校验位，共 64 位），安全性较低，逐渐被 AES 替代。

• 关键要求：密钥（Key）和 IV 长度必须为 8 字节。

• 代码实现（DESHelper）：

  // 核心逻辑与AES类似，使用DESCryptoServiceProvider → 创建加密/解密器 → 操作CryptoStream

  注：因安全性不足，目前主要用于兼容旧系统，新场景优先选 AES。

2. 非对称加密算法（RSA）

核心逻辑：基于大质数分解难题，公钥可公开，私钥需保密。加密用公钥，解密必须用对应的私钥。

• 特点：

  • 安全性高（破解需极大算力），但加密速度慢（比对称加密慢 100-1000 倍）。

  • 适合加密小数据（如对称加密的密钥），而非大量数据。

• 代码实现（RSAHelper）：

  // 加密：用公钥加密字节数组 → 转Base64
  // 解密：用私钥解密Base64字节 → 转明文

  注：示例简化了密钥管理，实际使用中需保存密钥对（

  rsa.ToXmlString(true)

  导出私钥，

  ToXmlString(false)

  导出公钥），否则每次创建

  RSACryptoServiceProvider

  会生成新密钥对，导致解密失败。

3. 散列算法（Hash 算法）

核心逻辑：通过哈希函数将任意长度数据映射为固定长度的哈希值（摘要），不可逆，相同输入必产生相同输出，不同输入大概率不同（抗碰撞性）。

（1）MD5 算法

• 特点：生成 128 位哈希值（32 位十六进制字符串），抗碰撞性较弱（已被破解），但速度快。

• 代码实现（MD5Helper）：

  // 流程：将明文转为字节 → 计算哈希 → 转十六进制字符串（大写X2）

  注：因安全性问题，不建议用于密码存储，可用于简单文件校验。

（2）SHA 系列算法

• 特点：包括 SHA-1（160 位）、SHA-256（256 位）、SHA-512（512 位）等，安全性远高于 MD5（SHA-256 至今未被有效破解）。

• 代码实现（SHAHelper）：

  // 逻辑同MD5，使用SHA256CryptoServiceProvider计算哈希 → 转十六进制（小写x2）

  注：SHA-256 是目前主流选择，适合密码存储（通常加盐增强安全性）、数字签名等场景。

三、核心算法对比表

对比维度	对称加密（AES/DES）	非对称加密（RSA）	散列算法（MD5/SHA）
可逆性	可逆（需密钥）	可逆（需私钥）	不可逆
密钥	单密钥（需保密）	公钥（公开）+ 私钥（保密）	无密钥（依赖算法）
速度	极快（适合大数据）	慢（适合小数据）	快
典型应用	本地文件加密	数字证书	密码存储、文件校验
安全性	取决于密钥管理	高（密钥无需传递）	SHA-256 > MD5

四、实用场景建议

1. 数据传输加密：用 AES 加密数据，RSA 加密 AES 的密钥（结合两者优势：AES 快，RSA 安全）。

2. 密码存储：用 SHA-256 + 盐值（Salt）加密（盐值随机，防止彩虹表破解）。

3. 文件完整性校验：计算文件的 SHA-256 哈希值，对比传输前后的哈希值判断是否篡改。

4. 旧系统兼容：若必须支持 legacy 系统，可保留 DES；新系统优先用 AES-256。

总结

加密算法的选择需权衡安全性 、性能 和场景需求 ：对称加密适合高效加密大数据，非对称加密适合安全密钥交换，散列算法适合数据校验。实际开发中，优先使用.NET 提供的原生加密类（如Aes、RSACryptoServiceProvider），避免自行实现加密逻辑（易引入安全漏洞）。

常用加密算法了解： C#中的加密解密方法：对称、非对称与散列算法详解-CSDN博客

MD5和DES加密及解密封装参考： C#：使用MD5对用户密码加密与解密 - Healer2047 - 博客园

AESHelper

using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace EncryptTool
{
    public static class AESHelper
    {
        private static readonly string keyString = ConfigurationManager.AppSettings["AESKEY"];
        // 它使用128、192或256位密钥
        private static readonly byte[] Key = Encoding.UTF8.GetBytes(keyString); // 16字节密钥
        private static readonly byte[] IV = Encoding.UTF8.GetBytes(keyString);  // 16字节初始化向量

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="data">明文</param>
        /// <returns>密文</returns>
        public static string Encrypt(string data)
        {
            using (Aes aesAlg = Aes.Create())
            {
                aesAlg.Key = Key;
                aesAlg.IV = IV;

                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(data);
                        }
                        return Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="data">密文</param>
        /// <returns>明文</returns>
        public static string Decrypt(string data)
        {
            using (Aes aesAlg = Aes.Create())
            {
                aesAlg.Key = Key;
                aesAlg.IV = IV;

                ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

                byte[] bytes = Convert.FromBase64String(data);

                using (MemoryStream msDecrypt = new MemoryStream(bytes))
                {
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                        {
                            return srDecrypt.ReadToEnd();
                        }
                    }
                }
            }
        }

    }
}

DESHelper

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

namespace EncryptTool
{
    public static class DESHelper
    {
        private static readonly string keyString = ConfigurationManager.AppSettings["DESKEY"];
        // 它使用56位密钥
        private static readonly byte[] Key = Encoding.UTF8.GetBytes(keyString); // 8字节密钥
        private static readonly byte[] IV = Encoding.UTF8.GetBytes(keyString);  // 8字节初始化向量

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="data">明文</param>
        /// <returns>密文</returns>
        public static string Encrypt(string data)
        {
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            {
                MemoryStream ms = new MemoryStream();
                CryptoStream encStream = new CryptoStream(ms, des.CreateEncryptor(Key, IV), CryptoStreamMode.Write);
                byte[] toEncrypt = Encoding.UTF8.GetBytes(data);
                encStream.Write(toEncrypt, 0, toEncrypt.Length);
                encStream.FlushFinalBlock();
                return Convert.ToBase64String(ms.ToArray());
            }
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="data">密文</param>
        /// <returns>明文</returns>
        public static string Decrypt(string data)
        {
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            {
                byte[] dataArray = Convert.FromBase64String(data);
                MemoryStream ms = new MemoryStream();
                CryptoStream decStream = new CryptoStream(ms, des.CreateDecryptor(Key, IV), CryptoStreamMode.Write);
                decStream.Write(dataArray, 0, dataArray.Length);
                decStream.FlushFinalBlock();
                return Encoding.UTF8.GetString(ms.ToArray());
            }
        }
    }
}

MD5Helper

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace EncryptTool
{
    public static class MD5Helper
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="data">明文</param>
        /// <returns>密文</returns>
        public static string Encrypt(string data)
        {
            // MD5它将任意长度的数据转换为128位的哈希值。
            using (var md5 = MD5.Create())
            {
                byte[] bytes = Encoding.ASCII.GetBytes(data);
                byte[] hashBytes = md5.ComputeHash(bytes);

                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < hashBytes.Length; i++)
                {
                    sb.Append(hashBytes[i].ToString("X2")); 
                }
                return sb.ToString();
            }
        }

    }
}

RSAHelper

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace EncryptTool
{
    public static class RSAHelper
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="data">明文</param>
        /// <returns>密文</returns>
        public static string Encrypt(string data)
        {
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                byte[] encrypted = rsa.Encrypt(Encoding.UTF8.GetBytes(data), false);
                return Convert.ToBase64String(encrypted);
            }
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="data">密文</param>
        /// <returns>明文</returns>
        public static string Decrypt(string data)
        {
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                byte[] decrypted = rsa.Decrypt(Encoding.UTF8.GetBytes(data), false);
                return Encoding.UTF8.GetString(decrypted);
            }
        }
    }
}

SHAHelper

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
​
namespace EncryptTool
{
    public static class SHAHelper
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="data">明文</param>
        /// <returns>密文</returns>
        public static string Encrypt(string data)
        {
            byte[] plainBytes = Encoding.UTF8.GetBytes(data);
            // 包括SHA-1、SHA-256、SHA-384和SHA-512。相比于MD5，SHA系列算法更安全。
            using (SHA256 cryptoProvider = new SHA256CryptoServiceProvider())
            {
                byte[] hashBytes = cryptoProvider.ComputeHash(plainBytes);
                StringBuilder hashBuilder = new StringBuilder();
                foreach (byte b in hashBytes)
                {
                    hashBuilder.Append(b.ToString("x2"));
                }
                return hashBuilder.ToString();
            }
        }
    }
}
​