RSA 加密解密

.NET_RsaEncryptProvider.cs

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

    /// <summary>
    /// RSA 加密解密辅助类
    /// 需要使用 XML 格式的公私钥，可以借助 .Net 5 的 RSACryptoServiceProvider 类，将其他格式的 Key 预先转换为 XML 格式
    /// </summary>
    public class RsaEncryptProvider
    {
        /// <summary>
        /// 私钥加密
        /// </summary>
        /// <param name="data">加密内容</param>
        /// <param name="privateKey">私钥（XML格式）</param>
        /// <returns>返回Base64内容</returns>
        /// <exception cref="Exception">调用此方法需要处理异常</exception>
        public string EncryptByPrivateKey(string data, string privateKeyXML)
        {
            data = data.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.FromXmlString(privateKeyXML);
                var result = rsa.Encrypt(Convert.FromBase64String(data), false);
                return Convert.ToBase64String(result);
            }
        }

        /// <summary>
        /// 私钥解密
        /// </summary>
        /// <param name="data">待解密的内容</param>
        /// <param name="privateKey">私钥（XML格式）</param>
        /// <returns>返回明文</returns>
        /// <exception cref="Exception">调用此方法需要处理异常</exception>
        public string DecryptByPrivateKey(string data, string privateKeyXML)
        {
            data = data.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.FromXmlString(privateKeyXML);
                var result = rsa.Decrypt(Convert.FromBase64String(data), false);
                return Encoding.UTF8.GetString(result);
            }
        }

        /// <summary>
        /// 公钥加密
        /// </summary>
        /// <param name="data">加密内容</param>
        /// <param name="publicKey">公钥（XML格式）</param>
        /// <returns>返回Base64内容</returns>
        /// <exception cref="Exception">调用此方法需要处理异常</exception>
        public string EncryptByPublicKey(string data, string publicKeyXML)
        {
            data = data.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.FromXmlString(publicKeyXML);
                var result = rsa.Encrypt(Convert.FromBase64String(data), false);
                return Convert.ToBase64String(result);
            }
        }

        /// <summary>
        /// 公钥解密
        /// </summary>
        /// <param name="data">待解密的内容</param>
        /// <param name="publicKey">公钥（XML格式）</param>
        /// <returns>返回明文</returns>
        /// <exception cref="Exception">调用此方法需要处理异常</exception>
        public string DecryptByPublicKey(string data, string publicKeyXML)
        {
            data = data.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.FromXmlString(publicKeyXML);
                var result = rsa.Decrypt(Convert.FromBase64String(data), false);
                return Encoding.UTF8.GetString(result);
            }
        }
    }

RsaEncryptProvider.cs

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

using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Crypto.Encodings;

namespace GrassDemoPark.WPF2.Tiny.Encrypt
{
    public class RsaEncryptProvider
    {
        private static readonly Encoding EncodingUtf8 = Encoding.UTF8;

        /// <summary>
        /// 私钥加密
        /// </summary>
        /// <param name="data">加密内容</param>
        /// <param name="privateKey">私钥（Base64格式）</param>
        /// <returns>返回Base64内容</returns>
        public string EncryptByPrivateKey(string data, string privateKey)
        {
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());

            //加密  
            try
            {
                engine.Init(true, RsaKeyGenerator.GetPrivateKeyParameter(privateKey));
                byte[] byteData = EncodingUtf8.GetBytes(data);
                var resultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return Convert.ToBase64String(resultData);
            }
            catch (Exception ex)
            {
                throw;
            }
        }

        /// <summary>
        /// 私钥解密
        /// </summary>
        /// <param name="data">待解密的内容</param>
        /// <param name="privateKey">私钥（Base64格式）</param>
        /// <returns>返回明文</returns>
        public string DecryptByPrivateKey(string data, string privateKey)
        {
            data = data.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());

            //解密  
            try
            {
                engine.Init(false, RsaKeyGenerator.GetPrivateKeyParameter(privateKey));
                byte[] byteData = Convert.FromBase64String(data);
                var resultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return EncodingUtf8.GetString(resultData);
            }
            catch (Exception ex)
            {
                throw;
            }
        }

        /// <summary>
        /// 公钥加密
        /// </summary>
        /// <param name="data">加密内容</param>
        /// <param name="publicKey">公钥（Base64编码后的）</param>
        /// <returns>返回Base64内容</returns>
        public string EncryptByPublicKey(string data, string publicKey)
        {
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());

            //加密  
            try
            {
                engine.Init(true, RsaKeyGenerator.GetPublicKeyParameter(publicKey));
                byte[] byteData = EncodingUtf8.GetBytes(data);
                var resultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return Convert.ToBase64String(resultData);
            }
            catch (Exception ex)
            {
                throw;
            }
        }

        /// <summary>
        /// 公钥解密
        /// </summary>
        /// <param name="data">待解密的内容</param>
        /// <param name="publicKey">公钥（Base64编码后的）</param>
        /// <returns>返回明文</returns>
        public string DecryptByPublicKey(string data, string publicKey)
        {
            data = data.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());

            //解密  
            try
            {
                engine.Init(false, RsaKeyGenerator.GetPublicKeyParameter(publicKey));
                byte[] byteData = Convert.FromBase64String(data);
                var resultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return EncodingUtf8.GetString(resultData);
            }
            catch (Exception ex)
            {
                throw;
            }
        }
    }
}

RsaKeyGenerator.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.X509;

namespace GrassDemoPark.WPF2.Tiny.Encrypt
{
    class RsaKeyGenerator
    {
        /// <summary>
        /// KEY 结构体
        /// </summary>
        public struct RsaKey
        {
            /// <summary>
            /// 公钥
            /// </summary>
            public string PublicKey
            {
                get;
                set;
            }

            /// <summary>
            /// 私钥
            /// </summary>
            public string PrivateKey
            {
                get;
                set;
            }
        }

        public static RsaKey GetKey()
        {
            //RSA密钥对的构造器  
            RsaKeyPairGenerator keyGenerator = new RsaKeyPairGenerator();

            //RSA密钥构造器的参数  
            RsaKeyGenerationParameters param = new RsaKeyGenerationParameters(
                Org.BouncyCastle.Math.BigInteger.ValueOf(3),
                new Org.BouncyCastle.Security.SecureRandom(),
                1024,   //密钥长度  
                25);
            //用参数初始化密钥构造器  
            keyGenerator.Init(param);
            //产生密钥对  
            AsymmetricCipherKeyPair keyPair = keyGenerator.GenerateKeyPair();
            //获取公钥和密钥  
            AsymmetricKeyParameter publicKey = keyPair.Public;
            AsymmetricKeyParameter privateKey = keyPair.Private;

            SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey);
            PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);


            Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();

            byte[] publicInfoByte = asn1ObjectPublic.GetEncoded("UTF-8");
            Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
            byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded("UTF-8");

            RsaKey item = new RsaKey()
            {
                PublicKey = Convert.ToBase64String(publicInfoByte),
                PrivateKey = Convert.ToBase64String(privateInfoByte)
            };
            return item;
        }

        public static AsymmetricKeyParameter GetPublicKeyParameter(string keyBase64)
        {
            keyBase64 = keyBase64.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            byte[] publicInfoByte = Convert.FromBase64String(keyBase64);
            Asn1Object pubKeyObj = Asn1Object.FromByteArray(publicInfoByte);//这里也可以从流中读取，从本地导入   
            AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(publicInfoByte);
            return pubKey;
        }

        public static AsymmetricKeyParameter GetPrivateKeyParameter(string keyBase64)
        {
            keyBase64 = keyBase64.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            byte[] privateInfoByte = Convert.FromBase64String(keyBase64);
            // Asn1Object priKeyObj = Asn1Object.FromByteArray(privateInfoByte);//这里也可以从流中读取，从本地导入   
            // PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
            AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(privateInfoByte);
            return priKey;
        }
    }
}

相关博客：
【转】C# RSA 加密，解密与签名，验证签名 - J.晒太阳的猫 - 博客园
C# RSA 加密，解密 - J.晒太阳的猫 - 博客园