.NET Framework 3.5框架如何使用RSA加密

在.NET Framework 3.5中，没有内置的方法直接解析PKCS#8格式的RSA私钥。但是，你可以使用第三方库如BouncyCastle来解析PKCS#8格式的私钥。以下是使用BouncyCastle库解析PKCS#8格式RSA私钥的示例代码：

首先，你需要安装BouncyCastle库。如果你使用NuGet，可以通过以下命令安装：
Install-Package BouncyCastle -Version 1.8.9

原理就是需要将第三方提供的RSA PKCS8私钥进行解码，然后返回实体类后，再将需要加密的报文信息携带私钥对象进行加密实现，代码如下

using System;
using System.Security.Cryptography;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Crypto.Parameters;
 
public class RsaPrivateKeyParser
{
    public static RSAParameters ParsePkcs8PrivateKey(string privateKey)
        {
            var privateKeyBytes = Convert.FromBase64String(privateKey);
            var parser = new Asn1InputStream(privateKeyBytes);
            var asn1 = parser.ReadObject();
            var privateKeyInfo = PrivateKeyInfo.GetInstance(asn1);
            //var algorithm = privateKeyInfo.PrivateKeyAlgorithm.AlgorithmID.Id;
            //if (algorithm != Org.BouncyCastle.Asn1.Pkcs.PkcsObjectIdentifiers.RsaEncryption.Id)
            //{
            //    throw new InvalidOperationException("Unsupported algorithm");
            //}

            var privateKeyParams = PrivateKeyFactory.CreateKey(privateKeyInfo);
            var rsaPrivateKeyParams = (RsaPrivateCrtKeyParameters)privateKeyParams;

            var rsa = new RSACryptoServiceProvider();
            var rsaParameters = new RSAParameters()
            {
                Modulus = rsaPrivateKeyParams.Modulus.ToByteArrayUnsigned(),
                Exponent = rsaPrivateKeyParams.PublicExponent.ToByteArrayUnsigned(),
                D = rsaPrivateKeyParams.Exponent.ToByteArrayUnsigned(),
                P = rsaPrivateKeyParams.P.ToByteArrayUnsigned(),
                Q = rsaPrivateKeyParams.Q.ToByteArrayUnsigned(),
                DP = rsaPrivateKeyParams.DP.ToByteArrayUnsigned(),
                DQ = rsaPrivateKeyParams.DQ.ToByteArrayUnsigned(),
                InverseQ = rsaPrivateKeyParams.QInv.ToByteArrayUnsigned()
            };

           // rsa.ImportParameters(rsaParameters);
            return rsaParameters;
        }

	//调用 得到加密后的RSA签名值
 	protected static string GetRSASign(string originalData,string privateKey)
        {
            string signatureBase64 = "";
            try
            {
                // 待加密的数据
                string data = originalData;

                // 导入PKCS8格式的私钥
                string privateKeyString = privateKey;
                //var privateKeyBytes = Encoding.UTF8.GetBytes(privateKeyString);
                //var privateKeyObject = DecodePrivateKey(privateKeyBytes);
                //var rsaParameters = DotNetUtilities.ToRSAParameters((RsaPrivateCrtKeyParameters)privateKeyObject);
                var rsaParameters = ParsePkcs8PrivateKey(privateKeyString);
                using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
                {
                    rsa.ImportParameters(rsaParameters);

                    // 计算SHA256摘要
                    byte[] dataBytes = Encoding.UTF8.GetBytes(data);
                    using (SHA256Managed sha256 = new SHA256Managed())
                    {
                        byte[] hashedData = sha256.ComputeHash(dataBytes);

                        // 使用RSA私钥进行签名
                        byte[] signature = rsa.SignHash(hashedData, "SHA256");

                        // Base64编码签名结果
                        signatureBase64 = Convert.ToBase64String(signature);
                    }
                }
                return signatureBase64;
            }
            catch (CryptographicException e)
            {

                return $"CryptographicException: {e.Message}";
            }
        }
}