C# 实现对称加密算法（AES）与非对称加密算法（RSA），包含前端加密对应算法实现

编程语言 2023-09-15 20:38:13 阅读次数: 0

C# 实现对称加密算法（AES）与非对称加密算法（RSA），包含前端对应加密算法实现

一、两者的含义

1、对称加密：

一种既简单速度又快的加密方式，加密与解密使用的都是同一个密钥，别名又叫做：单密钥加密；对称加密有很多公开算法，并且因为它效率很高，所以适用于加密大量数据的场合；但其密钥的传输过程是不安全的，并且容易被破解，密钥管理起来也相对麻烦。

2、非对称加密：

需要两个密钥来进行加密和解密，这两个密钥是公开密钥（public key，简称公钥）和私有密钥（private key，简称私钥），如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。加密密钥是公开的，密钥的分配和管理就很简单，而且能够很容易地实现数字签名，因此最适合于电子商务应用的需要；但是如果对大数量进行操作，计算量特别大，速度远远比不上对称加密。

详细请阅读这篇文章 https://blog.csdn.net/qq_38556796/article/details/126706393

二、后端代码实现

1、AES对称加密算法（CBC模式，多一个初始化向量，安全性高）

IV：初始化向量，配合秘钥一起使用，每次加密时随机生成，解密需要秘钥与IV一起才能解密
代码如下：

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

namespace Aes
{
    
    
    public class AesHelper
    {
    
    
        private const int KEY_SIZE = 256;
        private const int BLOCK_SIZE = 128;
        private const string KEY_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        private const string IV_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

        public static string Encrypt(string plainText, string key, string iv)
        {
    
    
            byte[] keyBytes = Encoding.UTF8.GetBytes(key);
            byte[] ivBytes = Encoding.UTF8.GetBytes(iv);

            using (Aes aes = Aes.Create())
            {
    
    
                aes.KeySize = KEY_SIZE;
                aes.BlockSize = BLOCK_SIZE;
                aes.Key = keyBytes;
                aes.IV = ivBytes;
                aes.Mode = CipherMode.CBC;

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

                byte[] plainBytes = Encoding.UTF8.GetBytes(plainText);

                using (MemoryStream ms = new MemoryStream())
                {
    
    
                    using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                    {
    
    
                        cs.Write(plainBytes, 0, plainBytes.Length);
                    }

                    byte[] encryptedBytes = ms.ToArray();

                    return Convert.ToBase64String(encryptedBytes);
                }
            }
        }

        public static string Decrypt(string cipherText, string key, string iv)
        {
    
    
            byte[] keyBytes = Encoding.UTF8.GetBytes(key);
            byte[] ivBytes = Encoding.UTF8.GetBytes(iv);

            using (Aes aes = Aes.Create())
            {
    
    
                aes.KeySize = KEY_SIZE;
                aes.BlockSize = BLOCK_SIZE;
                aes.Key = keyBytes;
                aes.IV = ivBytes;
                aes.Mode = CipherMode.CBC;

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

                byte[] cipherBytes = Convert.FromBase64String(cipherText);

                using (MemoryStream ms = new MemoryStream())
                {
    
    
                    using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write))
                    {
    
    
                        cs.Write(cipherBytes, 0, cipherBytes.Length);
                    }

                    byte[] decryptedBytes = ms.ToArray();

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

        public static string GenerateKey()
        {
    
    
            Random random = new Random();
            StringBuilder sb = new StringBuilder();

            for (int i = 0; i < KEY_SIZE / 8; i++)
            {
    
    
                int index = random.Next(KEY_CHARS.Length);
                sb.Append(KEY_CHARS[index]);
            }

            return sb.ToString();
        }

        public static string GenerateIV()
        {
    
    
            Random random = new Random();
            StringBuilder sb = new StringBuilder();

            for (int i = 0; i < BLOCK_SIZE / 8; i++)
            {
    
    
                int index = random.Next(IV_CHARS.Length);
                sb.Append(IV_CHARS[index]);
            }

            return sb.ToString();
        }
    }
}

1.1、加解密测试：

string plainText = "Hello World!";
string key = AesHelper.GenerateKey();
string iv = AesHelper.GenerateIV();

string cipherText = AesHelper.Encrypt(plainText, key, iv);
string decryptedText = AesHelper.Decrypt(cipherText, key, iv);

Console.WriteLine("Plain text: {0}", plainText);
Console.WriteLine("Cipher text: {0}", cipherText);
Console.WriteLine("Decrypted text: {0}", decryptedText);

2、AES对称加密算法（ECB模式，无需初始化向量）

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

namespace AesHelper
{
    
    
    public class Aes
    {
    
    
        /// <summary>
        /// AES算法的keysize有一定限制。
        /// 具体来说，AES算法支持的keysize为 128 bits、192 bits 和 256 bits，而且只能以16 bits（即2个字节）为步长递增。
        /// 也就是说，支持的有效的 keysize 可以是：128、160、192、224 或 256。
        /// 需要注意的是，AES算法的 keysize 越大，加密强度越高，但同时也会增加加密运算所需的时间和计算资源。
        /// 因此，在实际应用中，需要根据实际需求和环境对 keysize 进行合理的选择。
        /// </summary>
        private static readonly int KeySize = 256;

        /// <summary>
        /// 生成秘钥
        /// </summary>
        /// <returns></returns>
        public static string GenerateKey()
        {
    
    
            using (var aes = Aes.Create())
            {
    
    
                aes.KeySize = KeySize;
                aes.Mode = CipherMode.ECB; // ECB 模式无需 IV 向量
                aes.Padding = PaddingMode.PKCS7;

                aes.GenerateKey();
                return Convert.ToBase64String(aes.Key);
            }
        }

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="plainText"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string Encrypt(string plainText, string key)
        {
    
    
            using (var aes = Aes.Create())
            {
    
    
                aes.KeySize = KeySize;
                aes.Mode = CipherMode.ECB; // ECB 模式无需 IV 向量
                aes.Padding = PaddingMode.PKCS7;
                aes.Key = Convert.FromBase64String(key);

                ICryptoTransform encryptor = aes.CreateEncryptor();

                byte[] plainBytes = Encoding.UTF8.GetBytes(plainText);
                byte[] cipherBytes = encryptor.TransformFinalBlock(plainBytes, 0, plainBytes.Length);

                return Convert.ToBase64String(cipherBytes);
            }
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="cipherText"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string Decrypt(string cipherText, string key)
        {
    
    
            using (var aes = Aes.Create())
            {
    
    
                aes.KeySize = KeySize;
                aes.Mode = CipherMode.ECB; // ECB 模式无需 IV 向量
                aes.Padding = PaddingMode.PKCS7;
                aes.Key = Convert.FromBase64String(key);

                ICryptoTransform decryptor = aes.CreateDecryptor();

                byte[] cipherBytes = Convert.FromBase64String(cipherText);
                byte[] plainBytes = decryptor.TransformFinalBlock(cipherBytes, 0, cipherBytes.Length);

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

2.1、加解密测试

string key = AesHelper.GenerateKey();

string plainText = "Hello, world!";
string cipherText = AesHelper.Encrypt(plainText, key);
Console.WriteLine(cipherText);

string decryptedPlainText = AesHelper.Decrypt(cipherText, key);
Console.WriteLine(decryptedPlainText);

3、RSA非对称加密算法

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

namespace RSA
{
    
    
    /// <summary>
    /// 在C#中，RSACryptoServiceProvider的KeySize属性可以设置为任意偶数位的值，
    /// 建议使用2048位或更长的密钥长度以提供足够的安全性，典型情况下，RSA密钥的长度为2048位。
    /// 尽管在理论上可以使用较小的密钥长度来加速RSA操作，但是使用较小的密钥可能会使RSA易受到攻击，
    /// 因此不推荐使用少于2048位的密钥长度。为了确保数据的安全，应该使用更长的密钥(根据实际需求选择)，并定期更换密钥。
    /// ----------------------------
    /// RSA验证签名的作用是确保接收到的数据没有经过篡改，并且确实是由发送方发送的。
    /// 在数字通信中，攻击者可能会截取通信并修改消息内容，然后将其发送给接收方，导致接收方无法正确解释消息或采取错误的行动。
    /// 通过使用RSA签名，发送方可以对消息进行数字签名，这个数字签名是通过使用发送方的私钥生成的。
    /// 接收方可以使用发送方的公钥来验证数字签名，如果验证成功，就意味着消息没有被篡改，并且确实是由发送方发送的。
    /// 如果验证失败，接收方就可以确定消息已被篡改或不是由发送方发送的。
    /// 该过程确保了消息的完整性和真实性，防止了中间人攻击。因此，在数字通信中，RSA验证签名是一种非常重要的安全机制。
    /// ----------------------------
    /// 【注意】：为了与jsencrypt.min.js互换数据，需要将生成的 publicKey 和 privateKey 中的 = 去除
    /// </summary>
    public class RsaHelper
    {
    
    
        /// <summary>
        /// 生成公钥和私钥
        /// </summary>
        /// <param name="keySize">密钥大小</param>
        /// <param name="privateKey">输出私钥</param>
        /// <param name="publicKey">输出公钥</param>
        public static void GenerateKeys(int keySize, out string privateKey, out string publicKey)
        {
    
    
            using (var rsa = new RSACryptoServiceProvider(keySize))
            {
    
    
                privateKey = Convert.ToBase64String(rsa.ExportRSAPrivateKey());
                publicKey = Convert.ToBase64String(rsa.ExportRSAPublicKey());
            }
        }

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="publicKey">公钥</param>
        /// <param name="data">要加密的数据</param>
        /// <returns>加密后的数据</returns>
        public static string Encrypt(string publicKey, string data)
        {
    
    
            using (var rsa = new RSACryptoServiceProvider())
            {
    
    
                rsa.ImportRSAPublicKey(Convert.FromBase64String(publicKey), out _);
                var bytes = Encoding.UTF8.GetBytes(data);
                var encryptedBytes = rsa.Encrypt(bytes, RSAEncryptionPadding.Pkcs1);
                return Convert.ToBase64String(encryptedBytes);
            }
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="privateKey">私钥</param>
        /// <param name="data">要解密的数据</param>
        /// <returns>解密后的数据</returns>
        public static string Decrypt(string privateKey, string data)
        {
    
    
            using (var rsa = new RSACryptoServiceProvider())
            {
    
    
                rsa.ImportRSAPrivateKey(Convert.FromBase64String(privateKey), out _);
                var encryptedBytes = Convert.FromBase64String(data);
                var decryptedBytes = rsa.Decrypt(encryptedBytes, RSAEncryptionPadding.Pkcs1);
                return Encoding.UTF8.GetString(decryptedBytes);
            }
        }

        /// <summary>
        /// RSA私钥签名
        /// </summary>
        /// <param name="privateKey">私钥</param>
        /// <param name="data">要签名的数据</param>
        /// <returns>签名数据</returns>
        public static string SignData(string privateKey, string data)
        {
    
    
            using (var rsa = new RSACryptoServiceProvider())
            {
    
    
                rsa.ImportRSAPrivateKey(Convert.FromBase64String(privateKey), out _);
                var bytes = Encoding.UTF8.GetBytes(data);
                var signatureBytes = rsa.SignData(bytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
                return Convert.ToBase64String(signatureBytes);
            }
        }

        /// <summary>
        /// 验证RSA签名
        /// </summary>
        /// <param name="publicKey">公钥</param>
        /// <param name="data">原始数据</param>
        /// <param name="signatureData">签名数据</param>
        /// <returns></returns>
        public static bool VerifyData(string publicKey, string data, string signatureData)
        {
    
    
            using (var rsa = new RSACryptoServiceProvider())
            {
    
    
                rsa.ImportRSAPublicKey(Convert.FromBase64String(publicKey), out _);
                var bytes = Encoding.UTF8.GetBytes(data);
                var signatureBytes = Convert.FromBase64String(signatureData);
                return rsa.VerifyData(bytes, signatureBytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
            }
        }
    }
}

3.1、加解密测试

//生成公钥和私钥
RsaHelper.GenerateKeys(2048, out var privateKey, out var publicKey);

//加密
var data = "Hello World!";
string encryptedData = RsaHelper.Encrypt(publicKey, data);

//解密
string decryptedData = RsaHelper.Decrypt(privateKey, encryptedData);

//签名
string signatureData = RsaHelper.SignData(privateKey, data);

//验证签名
bool isVerify = RsaHelper.VerifyData(publicKey, data, signatureData);

Console.WriteLine($"公钥：{
      
      publicKey} \n");
Console.WriteLine($"私钥：{
      
      privateKey} \n");
Console.WriteLine($"密文：{
      
      encryptedData} \n");
Console.WriteLine($"解密明文：{
      
      decryptedData} \n");
Console.WriteLine($"签名：{
      
      signatureData} \n");
Console.WriteLine($"验证签名：{
      
      isVerify} \n");

三、前端代码实现

在这里插入图片描述
在这里插入图片描述

已打包成资源供各位下载查阅：https://download.csdn.net/download/qq_41970599/87898493

猜你喜欢

转载自blog.csdn.net/qq_41970599/article/details/131134770
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022