C# RSA非对称加密实战：从原理到跨平台对接与性能优化

1. 项目概述：为什么C#开发者绕不开RSA？

如果你用C#做过任何涉及数据安全传输或存储的功能，比如用户密码令牌、支付接口签名、配置文件加密，那你大概率听说过或者用过RSA。这玩意儿就像程序世界的“数字信封”：发信人用一把公开的锁（公钥）把信锁进信封，只有持有唯一钥匙（私钥）的收信人才能打开。在C#的生态里，RSACryptoServiceProvider和它的继任者RSA类，是我们实现这套“信封”逻辑的直接工具。

但说实话，我第一次用RSACryptoServiceProvider的时候，被那一串XML格式的密钥给整懵了。别的平台，比如Java或者OpenSSL，生成的密钥常常是一段PEM格式的Base64字符串，干净利落。而C#默认吐出来的是裹着一堆XML标签的“臃肿”字符串。这直接导致了一个非常现实的问题：当你需要和第三方系统（比如一个用Java写的后端服务）进行RSA加密通信时，密钥格式不匹配，对接起来简直是一场灾难。你可能会遇到“RSA public key not find”或者“密钥格式无效”这类让人头疼的错误。

所以，今天聊的“C#实现RSA非对称加密与解密”，远不止是调用两个API那么简单。它至少包含三个核心层面：第一，如何在C#中正确地生成、使用密钥对进行加密和解密；第二，如何理解并处理C#特有的XML密钥格式与其他通用格式（如PEM、PKCS#8）之间的转换；第三，在实际项目中，如何规避那些教科书上不会写的坑，比如密钥长度选择、填充模式、以及如何处理分段加密大数据。这些经验，都是我在多次跨平台对接和安全性审计中一点点攒下来的。

2. 核心原理与.NET中的RSA实现演进

在深入代码之前，我们得先统一一下思想。RSA算法的安全性，建立在“大数质因数分解极其困难”这个数学难题之上。简单说，你公开一个非常大的数n（它是两个大质数p和q的乘积），别人可以用n和另一个公开数e（公钥指数）来加密数据。但想解密，就必须知道p和q，从而计算出私钥指数d。对于足够大的n（例如2048位），以目前的计算能力，分解它在时间上是不现实的。

.NET框架为我们封装了所有这些复杂的数学运算。但需要注意的是，.NET中的RSA实现有过一次重要的演进。

2.1 从 RSACryptoServiceProvider 到 RSA 基类

在.NET Framework早期以及.NET Core 3.0之前，我们主要使用RSACryptoServiceProvider这个类。它位于System.Security.Cryptography命名空间下，功能强大但也有一些历史包袱，比如它严重依赖Windows的CryptoAPI，在非Windows系统上受限（虽然.NET Core做了兼容），而且默认的密钥导出格式就是XML。

// .NET Framework / 传统用法 using (var rsa = new RSACryptoServiceProvider(2048)) { string privateKeyXml = rsa.ToXmlString(true); // 导出包含私钥的XML string publicKeyXml = rsa.ToXmlString(false); // 导出仅含公钥的XML }

随着.NET Core和.NET 5+的跨平台战略推进，微软引入了更抽象、更灵活的RSA抽象基类，以及它的标准实现RSA.Create()。这个工厂方法会根据运行平台返回最合适的实现（在Windows上可能是RSACryptoServiceProvider的封装，在Linux/macOS上可能是基于OpenSSL的实现）。更重要的是，它支持更现代的密钥格式，如PEM。

// .NET 5+ 推荐用法 using System.Security.Cryptography; using (RSA rsa = RSA.Create()) { rsa.KeySize = 2048; // 设置密钥长度 // 导出为PEM格式（.NET 5+ 开始内置支持） string privateKeyPem = rsa.ExportRSAPrivateKeyPem(); string publicKeyPem = rsa.ExportRSAPublicKeyPem(); // 或者导出为XML（兼容旧代码） string privateKeyXml = rsa.ToXmlString(true); }

2.2 密钥长度与安全性的权衡

在生成密钥时，第一个要做的选择就是密钥长度。长度直接关系到安全性。RSACryptoServiceProvider的构造函数接受一个密钥长度参数，单位是比特（bit）。

• 1024位：目前已被认为是不安全的，许多新的安全标准（如PCI DSS）已明确禁止使用。仅在遗留内部系统中可能见到。
• 2048位：当前绝对的主流和最低安全要求。广泛应用于HTTPS（TLS）、代码签名、电子邮件加密等场景。在可预见的未来十几年内是安全的。
• 3072位：更高安全级别的要求，用于保护有效期非常长的数据或应对未来算力提升。
• 4096位及以上：用于最高安全级别的场景，但加解密性能会显著下降。

实操心得：对于绝大多数应用，无脑选择2048位即可。除非你有明确的合规性要求（比如金融行业某些规范要求3072位），否则不要盲目使用更长的密钥，因为加解密速度会变慢，而且有些老旧系统或库可能不支持超长密钥。生成密钥是一个比较耗CPU的操作，尽量避免在每次请求时动态生成。

2.3 填充模式：PKCS#1 v1.5 与 OAEP

当你调用Encrypt或Decrypt方法时，通常会看到一个名为fOAEP（在旧API中）或padding的参数。这指定了RSA加密的填充模式。填充是必须的，因为RSA算法本身是确定性的，对同样的明文和密钥，总会产生同样的密文。不加填充容易受到多种攻击。

• PKCS#1 v1.5 Padding (fOAEP: false)：一种较老的填充方案。它在历史上被广泛使用，但已知存在一些潜在的理论漏洞（如Bleichenbacher攻击）。在现代应用中，不推荐使用。
• OAEP Padding (fOAEP: true / RSAEncryptionPadding.OaepSHA1)：最优非对称加密填充。它提供了更强的安全性，是当前推荐的标准。在.NET中，通常与SHA-1或SHA-256等哈希算法结合使用（如RSAEncryptionPadding.OaepSHA256）。

// 现代、安全的加密方式（.NET Core / .NET 5+） byte[] dataToEncrypt = Encoding.UTF8.GetBytes("Hello, RSA!"); byte[] encryptedData = rsa.Encrypt(dataToEncrypt, RSAEncryptionPadding.OaepSHA256);

注意事项：填充模式在加密和解密时必须严格匹配。如果你用OaepSHA256加密，就必须用OaepSHA256解密。用错填充模式是导致解密失败最常见的原因之一，错误信息通常是“无效的数据”或“填充无效，无法被移除”。在跨平台交互时，双方必须明确约定并统一使用相同的填充模式，通常OAEP是首选。

3. 从生成到使用：一套完整的C# RSA加解密流程

理论说再多，不如一行代码。我们从一个完整的、可运行的控制台示例开始，看看在.NET 6+的环境下，如何完成密钥生成、加密、解密的闭环。

3.1 密钥生成与存储

首先，我们生成一对2048位的RSA密钥，并分别以XML和PEM两种格式导出保存。这能让你直观地看到两种格式的区别。

using System.Security.Cryptography; using System.Text; namespace RsaDemo { class Program { static void Main(string[] args) { // 1. 创建RSA实例并生成密钥 using (RSA rsa = RSA.Create(2048)) // 明确指定2048位长度 { Console.WriteLine($"生成的RSA密钥长度: {rsa.KeySize} 位"); // 2. 导出各种格式的密钥 // XML格式（C#传统格式，包含所有参数） string privateKeyXml = rsa.ToXmlString(true); string publicKeyXml = rsa.ToXmlString(false); // PEM格式（.NET 5+ 原生支持，跨平台通用） string privateKeyPem = rsa.ExportRSAPrivateKeyPem(); // PKCS#1 格式 string publicKeyPem = rsa.ExportRSAPublicKeyPem(); // 也可以导出为PKCS#8格式的PEM（更通用） string privateKeyPkcs8Pem = rsa.ExportPkcs8PrivateKeyPem(); Console.WriteLine("=== 私钥 (XML) ==="); Console.WriteLine(privateKeyXml[..100] + "..."); // 打印前100字符 Console.WriteLine("\n=== 公钥 (PEM) ==="); Console.WriteLine(publicKeyPem); // 3. 将密钥保存到文件（实际项目应妥善保管私钥！） File.WriteAllText("private_key.pem", privateKeyPem); File.WriteAllText("public_key.pem", publicKeyPem); File.WriteAllText("private_key.xml", privateKeyXml); Console.WriteLine("\n密钥已保存至文件。"); } } } }

运行这段代码，你会在bin目录下得到三个文件。打开public_key.pem，你会看到类似这样的内容：

-----BEGIN RSA PUBLIC KEY----- MIIBCgKCAQEAwV2l...（Base64编码数据）...AwIDAQAB -----END RSA PUBLIC KEY-----

而private_key.xml则是一大段XML，里面包含了Modulus、Exponent、D、P、Q、DP、DQ、InverseQ等所有RSA参数。

重要安全警告：私钥（尤其是private_key.pem和private_key.xml）是最高机密，绝不能提交到代码仓库（如Git）、存放在客户端或通过不安全的渠道传输。在生产环境中，私钥通常存放在服务器的密钥保管库（如Azure Key Vault、AWS KMS）、硬件安全模块（HSM）或受严格权限控制的配置文件中。

3.2 使用公钥加密数据

现在，假设我们有一个独立的“发送方”程序，它只拥有公钥，需要加密一段信息。

// 发送方 - 仅持有公钥 static byte[] EncryptWithPublicKey(string publicKeyPem, string plainText) { byte[] plainData = Encoding.UTF8.GetBytes(plainText); using (RSA rsa = RSA.Create()) { // 从PEM格式字符串导入公钥 rsa.ImportFromPem(publicKeyPem.ToCharArray()); // 使用OAEP with SHA-256填充进行加密（推荐） // RSA加密有长度限制，加密数据长度 <= (密钥长度/8) - 填充开销 // 对于2048位密钥和OAEP SHA-256，最大明文长度约为 256 - 66 = 190字节 if (plainData.Length > 190) { throw new ArgumentException($"明文数据过长。对于2048位RSA-OAEP，最大支持约190字节，当前为{plainData.Length}字节。"); } byte[] encryptedData = rsa.Encrypt(plainData, RSAEncryptionPadding.OaepSHA256); return encryptedData; } }

3.3 使用私钥解密数据

接收方持有私钥，负责解密。

// 接收方 - 持有私钥 static string DecryptWithPrivateKey(string privateKeyPem, byte[] encryptedData) { using (RSA rsa = RSA.Create()) { // 从PEM格式字符串导入私钥 rsa.ImportFromPem(privateKeyPem.ToCharArray()); // 使用相同的填充模式解密 byte[] decryptedData = rsa.Decrypt(encryptedData, RSAEncryptionPadding.OaepSHA256); return Encoding.UTF8.GetString(decryptedData); } }

3.4 串联测试

在主函数中，我们可以模拟这个流程：

// 模拟发送方 string originalMessage = "这是一条需要加密的敏感信息，比如交易流水号：TX20231027001"; string publicKey = File.ReadAllText("public_key.pem"); byte[] cipherData = EncryptWithPublicKey(publicKey, originalMessage); Console.WriteLine($"加密后的数据 (Base64): {Convert.ToBase64String(cipherData)}"); // 模拟接收方 string privateKey = File.ReadAllText("private_key.pem"); string decryptedMessage = DecryptWithPrivateKey(privateKey, cipherData); Console.WriteLine($"解密后的消息: {decryptedMessage}"); Console.WriteLine($"解密是否成功: {originalMessage == decryptedMessage}");

如果一切顺利，你会看到加密后的密文（一串Base64字符串），以及成功解密还原的原文。

4. 密钥格式转换：解决跨平台对接的核心难题

如果你只需要在纯C#环境内加解密，那么用上面的ExportRSAPrivateKeyPem和ImportFromPem就足够了。但现实很骨感，你经常需要和Java、Python、Node.js甚至硬件设备交互，它们使用的密钥格式五花八门。这时，格式转换就成了刚需。

4.1 常见的密钥格式

1. XML：.NET Framework的“祖传”格式，包含所有参数，人类可读但冗长。
2. PEM：最常见的文本格式，以-----BEGIN XXX-----和-----END XXX-----包裹Base64数据。它本身是一个容器，里面可以装不同的数据格式。
3. PKCS#1：传统的RSA密钥标准，PEM标签通常是BEGIN RSA PRIVATE KEY。
4. PKCS#8：更通用的私钥标准，可以封装多种算法（包括RSA），标签是BEGIN PRIVATE KEY（不包含算法标识）或BEGIN ENCRYPTED PRIVATE KEY（加密的）。.NET 5+ 默认导出的PEM私钥是PKCS#1格式，但可以通过ExportPkcs8PrivateKeyPem导出PKCS#8。
5. DER：上述所有格式的二进制版本，是直接编码的ASN.1结构。

4.2 使用BouncyCastle进行高级转换

虽然.NET Core/5+ 在PEM支持上有了巨大进步，但对于一些复杂的转换（比如从PKCS#1到PKCS#8，或者处理加密的PEM），或者你还在使用.NET Framework，那么BouncyCastle这个强大的第三方加密库几乎是必不可少的。它提供了极其丰富的格式支持和底层操作能力。

首先，通过NuGet安装：Install-Package BouncyCastle.Cryptography或dotnet add package BouncyCastle.Cryptography。

下面是一个功能更全面的转换工具类，它解决了我在实际对接Java Spring Boot服务时遇到的具体问题：

using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.OpenSsl; using Org.BouncyCastle.Security; using System.Security.Cryptography; using System.Text; public class RsaKeyConverter { /// <summary> /// 将.NET RSA实例中的私钥转换为PKCS#8格式的PEM字符串（无密码加密）。 /// 此格式被Java的PKCS8EncodedKeySpec广泛支持。 /// </summary> public static string ExportPrivateKeyToPkcs8Pem(RSA rsa) { RSAParameters rsaParams = rsa.ExportParameters(true); RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters( new Org.BouncyCastle.Math.BigInteger(1, rsaParams.Modulus), new Org.BouncyCastle.Math.BigInteger(1, rsaParams.Exponent), new Org.BouncyCastle.Math.BigInteger(1, rsaParams.D), new Org.BouncyCastle.Math.BigInteger(1, rsaParams.P), new Org.BouncyCastle.Math.BigInteger(1, rsaParams.Q), new Org.BouncyCastle.Math.BigInteger(1, rsaParams.DP), new Org.BouncyCastle.Math.BigInteger(1, rsaParams.DQ), new Org.BouncyCastle.Math.BigInteger(1, rsaParams.InverseQ) ); using (StringWriter writer = new StringWriter()) { PemWriter pemWriter = new PemWriter(writer); pemWriter.WriteObject(privateKeyParam); pemWriter.Writer.Flush(); return writer.ToString(); // 输出为 PKCS#1 PEM } // 注意：上述代码实际输出PKCS#1。要得到PKCS#8，需要稍复杂的ASN.1序列化。 // 更简单的方式是直接使用.NET 5+的 ExportPkcs8PrivateKeyPem()。 } /// <summary> /// 将PKCS#8 PEM格式的私钥（Java常见格式）加载到.NET的RSA实例中。 /// 这个方法能处理“BEGIN PRIVATE KEY”标签。 /// </summary> public static RSA ImportPrivateKeyFromPkcs8Pem(string pemString) { using (StringReader reader = new StringReader(pemString)) { PemReader pemReader = new PemReader(reader); object keyObject = pemReader.ReadObject(); RsaPrivateCrtKeyParameters privateKeyParams; if (keyObject is AsymmetricCipherKeyPair keyPair) { // 如果PEM包含的是密钥对（BEGIN RSA PRIVATE KEY） privateKeyParams = (RsaPrivateCrtKeyParameters)keyPair.Private; } else if (keyObject is RsaPrivateCrtKeyParameters rsaPrivate) { // 如果直接读出的就是私钥参数 privateKeyParams = rsaPrivate; } else { throw new InvalidOperationException("不支持的PEM格式或不是RSA私钥。"); } RSAParameters rsaParams = new RSAParameters { Modulus = privateKeyParams.Modulus.ToByteArrayUnsigned(), Exponent = privateKeyParams.PublicExponent.ToByteArrayUnsigned(), D = privateKeyParams.Exponent.ToByteArrayUnsigned(), P = privateKeyParams.P.ToByteArrayUnsigned(), Q = privateKeyParams.Q.ToByteArrayUnsigned(), DP = privateKeyParams.DP.ToByteArrayUnsigned(), DQ = privateKeyParams.DQ.ToByteArrayUnsigned(), InverseQ = privateKeyParams.QInv.ToByteArrayUnsigned() }; RSA rsa = RSA.Create(); rsa.ImportParameters(rsaParams); return rsa; } } /// <summary> /// 从标准的“BEGIN PUBLIC KEY” PEM格式导入公钥。 /// 这种格式是SubjectPublicKeyInfo结构，Java的X509EncodedKeySpec使用它。 /// </summary> public static RSA ImportPublicKeyFromX509Pem(string pemString) { using (StringReader reader = new StringReader(pemString)) { PemReader pemReader = new PemReader(reader); object keyObject = pemReader.ReadObject(); RsaKeyParameters publicKeyParams; if (keyObject is RsaKeyParameters rsaKey) { publicKeyParams = rsaKey; } else if (keyObject is AsymmetricCipherKeyPair keyPair) { // 有些PEM可能错误地包含了密钥对，但我们需要公钥 publicKeyParams = (RsaKeyParameters)keyPair.Public; } else { throw new InvalidOperationException("不支持的PEM格式或不是RSA公钥。"); } RSAParameters rsaParams = new RSAParameters { Modulus = publicKeyParams.Modulus.ToByteArrayUnsigned(), Exponent = publicKeyParams.Exponent.ToByteArrayUnsigned() }; RSA rsa = RSA.Create(); rsa.ImportParameters(rsaParams); return rsa; } } }

踩坑实录：我曾经对接一个Java服务，对方发来的公钥PEM标签是BEGIN PUBLIC KEY。我直接用.NET 6的ImportFromPem，死活报错。后来发现，ImportFromPem对标签格式比较挑剔。而用BouncyCastle的PemReader可以更灵活地解析。关键是要弄清楚对方给你的到底是什么格式。一个快速判断的方法是：BEGIN RSA PUBLIC KEY通常是PKCS#1格式；而BEGIN PUBLIC KEY是X.509/SubjectPublicKeyInfo (PKCS#8公钥) 格式。Java的KeyPairGenerator默认生成的是后者。

5. 应对长数据：分段加密与混合加密模式

RSA算法有一个硬性限制：它不能直接加密超过密钥长度的数据。对于2048位（256字节）的密钥，使用OAEP填充后，最大加密明文长度可能只有190字节左右。这显然无法满足加密长文本、文件等需求。解决这个问题有两种主流方案。

5.1 分段加密与解密

思路很简单：把长数据切成多个符合长度限制的小块，分别加密，再拼接起来。解密时反向操作。这种方法虽然直观，但效率低，且密文会膨胀（因为每个小块加密后长度都等于密钥长度）。

public static byte[] RsaEncryptLongData(RSA rsa, byte[] data, RSAEncryptionPadding padding) { int keySize = rsa.KeySize / 8; // 密钥字节长度 int maxBlockSize = padding == RSAEncryptionPadding.Pkcs1 ? keySize - 11 : keySize - 42; // 粗略估算，OAEP开销更大 // 更准确的做法应根据填充模式计算，OAEP SHA-256 开销约66字节 using (MemoryStream msOutput = new MemoryStream()) { for (int offset = 0; offset < data.Length; offset += maxBlockSize) { int blockSize = Math.Min(maxBlockSize, data.Length - offset); byte[] block = new byte[blockSize]; Buffer.BlockCopy(data, offset, block, 0, blockSize); byte[] encryptedBlock = rsa.Encrypt(block, padding); msOutput.Write(encryptedBlock, 0, encryptedBlock.Length); } return msOutput.ToArray(); } } public static byte[] RsaDecryptLongData(RSA rsa, byte[] encryptedData, RSAEncryptionPadding padding) { int keySize = rsa.KeySize / 8; int blockSize = keySize; // 密文块大小固定为密钥长度 using (MemoryStream msOutput = new MemoryStream()) { for (int offset = 0; offset < encryptedData.Length; offset += blockSize) { int currentBlockSize = Math.Min(blockSize, encryptedData.Length - offset); byte[] block = new byte[currentBlockSize]; Buffer.BlockCopy(encryptedData, offset, block, 0, currentBlockSize); byte[] decryptedBlock = rsa.Decrypt(block, padding); msOutput.Write(decryptedBlock, 0, decryptedBlock.Length); } return msOutput.ToArray(); } }

重要警告：RSA标准本身并不直接定义或推荐这种分段加密模式。它破坏了密文的完整性，且需要自己处理分块边界，容易出错。在实践中，更通用、更安全的方案是下面要讲的“混合加密”。

5.2 混合加密：RSA + AES（推荐方案）

这是业界标准的做法，结合了非对称加密和对称加密的优点：

1. 随机生成一个一次性的对称密钥（比如AES-256的密钥）。
2. 使用这个对称密钥，用AES算法加密你的长数据。AES加密速度快，适合大数据量。
3. 使用接收方的RSA公钥，加密上一步生成的对称密钥。
4. 将加密后的对称密钥和AES加密后的数据一起发送给接收方。
5. 接收方用自己的RSA私钥解密出对称密钥，再用对称密钥解密出原始数据。

这样，RSA只用于加密很小的对称密钥（比如32字节），完美避开了长度限制，同时利用AES保证了大数据加密的性能。

using System.Security.Cryptography; public class HybridEncryption { public static (byte[] encryptedSessionKey, byte[] iv, byte[] encryptedData) Encrypt(byte[] data, RSA rsaPublicKey) { // 1. 生成随机的AES密钥和初始化向量(IV) using (Aes aes = Aes.Create()) { aes.KeySize = 256; // AES-256 aes.GenerateKey(); aes.GenerateIV(); byte[] sessionKey = aes.Key; byte[] iv = aes.IV; // 2. 用AES加密数据 byte[] encryptedData; using (ICryptoTransform encryptor = aes.CreateEncryptor()) { encryptedData = encryptor.TransformFinalBlock(data, 0, data.Length); } // 3. 用RSA公钥加密AES密钥 byte[] encryptedSessionKey = rsaPublicKey.Encrypt(sessionKey, RSAEncryptionPadding.OaepSha256); return (encryptedSessionKey, iv, encryptedData); } } public static byte[] Decrypt(byte[] encryptedSessionKey, byte[] iv, byte[] encryptedData, RSA rsaPrivateKey) { // 1. 用RSA私钥解密出AES密钥 byte[] sessionKey = rsaPrivateKey.Decrypt(encryptedSessionKey, RSAEncryptionPadding.OaepSha256); // 2. 用解密出的AES密钥和IV解密数据 using (Aes aes = Aes.Create()) { aes.Key = sessionKey; aes.IV = iv; using (ICryptoTransform decryptor = aes.CreateDecryptor()) { return decryptor.TransformFinalBlock(encryptedData, 0, encryptedData.Length); } } } }

这种模式被广泛应用于TLS/SSL、PGP、S/MIME等安全协议中，是处理任意长度数据加密的最佳实践。

6. 实战问题排查与性能调优指南

即使理解了所有原理，在实际编码和运维中，你依然会遇到各种稀奇古怪的问题。下面是我总结的一些常见“坑点”和解决思路。

6.1 常见错误与排查清单

6.2 性能考量与最佳实践

RSA加解密是CPU密集型操作，非常慢。以下是一些优化建议：

1. 缓存RSA实例：不要每次加解密都new RSACryptoServiceProvider()或RSA.Create()。生成或导入密钥后，将RSA实例缓存起来（注意线程安全）。因为密钥生成和导入（尤其是从XML/PEM字符串）开销很大。
2. 区分使用场景：
   • 加密：使用公钥操作，可以公开进行，性能相对可接受。
   • 解密/签名：使用私钥操作，是性能瓶颈。应尽量减少调用频率。例如，在Web API中，不要用RSA解密每个请求的body，而是用RSA解密一个会话密钥，然后用更快的AES来解密后续请求。
3. 使用合适的密钥长度：如前所述，2048位是安全与性能的平衡点。非必要不使用更长密钥。
4. 考虑使用ECC：对于新项目，如果主要用途是数字签名（而非加密），可以考虑椭圆曲线加密（ECC）。它在相同安全强度下，密钥更短、速度更快、资源消耗更少。.NET也提供了ECDsa类支持。

6.3 一个真实的调试案例：与Java服务对接

我曾遇到一个需求：我们的C#客户端需要调用一个Java Spring Boot服务的接口，该接口要求用RSA公钥加密请求中的某个字段。Java后端给了我一个public.key文件。

第一步：检查密钥格式。用文本编辑器打开，内容是-----BEGIN PUBLIC KEY-----开头。这是标准的X.509 SubjectPublicKeyInfo格式。

第二步：尝试直接导入。使用.NET 6的rsa.ImportFromPem(publicKeyText)，失败，提示格式错误。

第三步：使用BouncyCastle。改用上面RsaKeyConverter.ImportPublicKeyFromX509Pem方法，成功导入。

第四步：加密并发送。用导入的公钥加密数据，将Base64后的密文放在JSON请求体中发送。

第五步：Java端解密失败。Java后台报错。经过联调，发现两个问题：

1. 填充模式不匹配：Java端默认使用的是RSA/ECB/PKCS1Padding，而我C#端用的是OaepSHA256。将C#端改为使用RSAEncryptionPadding.Pkcs1后解决。
2. Base64编码换行符：Java端的Base64编码器默认会每76字符加一个换行，而C#的Convert.ToBase64String默认不加。需要确保传输的密文字符串是“紧凑”的，或者在解码时能处理换行符。

最终，确保两端在密钥格式、填充模式、编码方式上完全一致，对接成功。这个案例充分说明了在跨系统加密通信中，细节决定成败。