RSA加解密助手类

安装Nuget包：

Install-Package Portable.BouncyCastle

RSACryption助手类

using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

public class RSACryption
{
  #region RSA 的密钥产生、转换
  /// <summary>
  /// RSA产生密钥
  /// </summary>
  /// <param name="xmlKeys">私钥</param>
  /// <param name="xmlPublicKey">公钥</param>
  public void RSAKey(out string xmlKeys, out string xmlPublicKey)
  {
      try
      {
          System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
          xmlKeys = rsa.ToXmlString(true);
          xmlPublicKey = rsa.ToXmlString(false);
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }

  /// <summary>
  /// XML公钥转成Pem公钥
  /// </summary>
  /// <param name="xmlPublicKey"></param>
  /// <returns></returns>
  public static string XmlPublicKeyToPem(string xmlPublicKey)
  {
      RSAParameters rsaParam;
      using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
      {
          rsa.FromXmlString(xmlPublicKey);
          rsaParam = rsa.ExportParameters(false);
      }
      RsaKeyParameters param = new RsaKeyParameters(false, new BigInteger(1, rsaParam.Modulus), new BigInteger(1, rsaParam.Exponent));

      string pemPublicKeyStr = null;
      using (var ms = new MemoryStream())
      {
          using (var sw = new StreamWriter(ms))
          {
              var pemWriter = new Org.BouncyCastle.OpenSsl.PemWriter(sw);
              pemWriter.WriteObject(param);
              sw.Flush();

              byte[] buffer = new byte[ms.Length];
              ms.Position = 0;
              ms.Read(buffer, 0, (int)ms.Length);
              pemPublicKeyStr = Encoding.UTF8.GetString(buffer);
          }
      }

      return pemPublicKeyStr;
  }

  /// <summary>
  /// Pem公钥转成XML公钥
  /// </summary>
  /// <param name="pemPublicKeyStr"></param>
  /// <returns></returns>
  public static string PemPublicKeyToXml(string pemPublicKeyStr)
  {
      RsaKeyParameters pemPublicKey;
      using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(pemPublicKeyStr)))
      {
          using (var sr = new StreamReader(ms))
          {
              var pemReader = new Org.BouncyCastle.OpenSsl.PemReader(sr);
              pemPublicKey = (RsaKeyParameters)pemReader.ReadObject();
          }
      }

      var p = new RSAParameters
      {
          Modulus = pemPublicKey.Modulus.ToByteArrayUnsigned(),
          Exponent = pemPublicKey.Exponent.ToByteArrayUnsigned()
      };

      string xmlPublicKeyStr;
      using (var rsa = new RSACryptoServiceProvider())
      {
          rsa.ImportParameters(p);
          xmlPublicKeyStr = rsa.ToXmlString(false);
      }

      return xmlPublicKeyStr;
  }

  /// <summary>
  /// XML私钥转成PEM私钥
  /// </summary>
  /// <param name="xmlPrivateKey"></param>
  /// <returns></returns>
  public static string XmlPrivateKeyToPem(string xmlPrivateKey)
  {
      RSAParameters rsaParam;
      using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
      {
          rsa.FromXmlString(xmlPrivateKey);
          rsaParam = rsa.ExportParameters(true);
      }

      var param = new RsaPrivateCrtKeyParameters(
      new BigInteger(1, rsaParam.Modulus), new BigInteger(1, rsaParam.Exponent), new BigInteger(1, rsaParam.D),
      new BigInteger(1, rsaParam.P), new BigInteger(1, rsaParam.Q), new BigInteger(1, rsaParam.DP), new BigInteger(1, rsaParam.DQ),
      new BigInteger(1, rsaParam.InverseQ));

      string pemPrivateKeyStr = null;
      using (var ms = new MemoryStream())
      {
          using (var sw = new StreamWriter(ms))
          {
              var pemWriter = new Org.BouncyCastle.OpenSsl.PemWriter(sw);
              pemWriter.WriteObject(param);
              sw.Flush();

              byte[] buffer = new byte[ms.Length];
              ms.Position = 0;
              ms.Read(buffer, 0, (int)ms.Length);
              pemPrivateKeyStr = Encoding.UTF8.GetString(buffer);
          }
      }

      return pemPrivateKeyStr;
  }

  /// <summary>
  /// Pem私钥转成XML私钥
  /// </summary>
  /// <param name="pemPrivateKeyStr"></param>
  /// <returns></returns>
  public static string PemPrivateKeyToXml(string pemPrivateKeyStr)
  {
      RsaPrivateCrtKeyParameters pemPrivateKey;
      using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(pemPrivateKeyStr)))
      {
          using (var sr = new StreamReader(ms))
          {
              var pemReader = new Org.BouncyCastle.OpenSsl.PemReader(sr);
              var keyPair = (AsymmetricCipherKeyPair)pemReader.ReadObject();
              pemPrivateKey = (RsaPrivateCrtKeyParameters)keyPair.Private;
          }
      }

      var p = new RSAParameters
      {
          Modulus = pemPrivateKey.Modulus.ToByteArrayUnsigned(),
          Exponent = pemPrivateKey.PublicExponent.ToByteArrayUnsigned(),
          D = pemPrivateKey.Exponent.ToByteArrayUnsigned(),
          P = pemPrivateKey.P.ToByteArrayUnsigned(),
          Q = pemPrivateKey.Q.ToByteArrayUnsigned(),
          DP = pemPrivateKey.DP.ToByteArrayUnsigned(),
          DQ = pemPrivateKey.DQ.ToByteArrayUnsigned(),
          InverseQ = pemPrivateKey.QInv.ToByteArrayUnsigned(),
      };

      string xmlPrivateKeyStr;
      using (var rsa = new RSACryptoServiceProvider())
      {
          rsa.ImportParameters(p);
          xmlPrivateKeyStr = rsa.ToXmlString(true);
      }

      return xmlPrivateKeyStr;
  }
  #endregion

  #region RSA 加密解密

  #region RSA加密函数
  //############################################################################## 
  //RSA 方式加密 
  //KEY必须是XML的形式,返回的是字符串 
  //该加密方式有长度限制的！
  //############################################################################## 

  /// <summary>
  /// RSA的加密函数
  /// </summary>
  /// <param name="xmlPublicKey">公钥</param>
  /// <param name="encryptString">待加密的字符串</param>
  /// <returns></returns>
  public string RSAEncrypt(string xmlPublicKey, string encryptString)
  {
      try
      {
          byte[] PlainTextBArray;
          byte[] CypherTextBArray;
          string Result;
          System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
          rsa.FromXmlString(xmlPublicKey);
          PlainTextBArray = (new UnicodeEncoding()).GetBytes(encryptString);
          CypherTextBArray = rsa.Encrypt(PlainTextBArray, false);
          Result = Convert.ToBase64String(CypherTextBArray);
          return Result;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }
  /// <summary>
  /// RSA的加密函数 
  /// </summary>
  /// <param name="xmlPublicKey">公钥</param>
  /// <param name="EncryptString">待加密的字节数组</param>
  /// <returns></returns>
  public string RSAEncrypt(string xmlPublicKey, byte[] EncryptString)
  {
      try
      {
          byte[] CypherTextBArray;
          string Result;
          System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
          rsa.FromXmlString(xmlPublicKey);
          CypherTextBArray = rsa.Encrypt(EncryptString, false);
          Result = Convert.ToBase64String(CypherTextBArray);
          return Result;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }
  #endregion

  #region RSA的解密函数        
  /// <summary>
  /// RSA的解密函数
  /// </summary>
  /// <param name="xmlPrivateKey">私钥</param>
  /// <param name="decryptString">待解密的字符串</param>
  /// <returns></returns>
  public string RSADecrypt(string xmlPrivateKey, string decryptString)
  {
      try
      {
          byte[] PlainTextBArray;
          byte[] DypherTextBArray;
          string Result;
          System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
          rsa.FromXmlString(xmlPrivateKey);
          PlainTextBArray = Convert.FromBase64String(decryptString);
          DypherTextBArray = rsa.Decrypt(PlainTextBArray, false);
          Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
          return Result;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }
  /// <summary>
  /// RSA的解密函数 
  /// </summary>
  /// <param name="xmlPrivateKey">私钥</param>
  /// <param name="DecryptString">待解密的字节数组</param>
  /// <returns></returns>
  public string RSADecrypt(string xmlPrivateKey, byte[] DecryptString)
  {
      try
      {
          byte[] DypherTextBArray;
          string Result;
          System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
          rsa.FromXmlString(xmlPrivateKey);
          DypherTextBArray = rsa.Decrypt(DecryptString, false);
          Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
          return Result;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }
  #endregion

  #endregion

  #region RSA数字签名

  #region 获取Hash描述表        
  /// <summary>
  /// 获取Hash描述表
  /// </summary>
  /// <param name="strSource">待签名的字符串</param>
  /// <param name="HashData">Hash描述</param>
  /// <returns></returns>
  public bool GetHash(string strSource, ref byte[] HashData)
  {
      try
      {
          byte[] Buffer;
          System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
          Buffer = System.Text.Encoding.GetEncoding("GB2312").GetBytes(strSource);
          HashData = MD5.ComputeHash(Buffer);
          return true;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }

  /// <summary>
  /// 获取Hash描述表
  /// </summary>
  /// <param name="strSource">待签名的字符串</param>
  /// <param name="strHashData">Hash描述</param>
  /// <returns></returns>
  public bool GetHash(string strSource, ref string strHashData)
  {
      try
      {
          //从字符串中取得Hash描述 
          byte[] Buffer;
          byte[] HashData;
          System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
          Buffer = System.Text.Encoding.Default.GetBytes(strSource);
          HashData = MD5.ComputeHash(Buffer);
          strHashData = Convert.ToBase64String(HashData);
          return true;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }

  /// <summary>
  /// 获取Hash描述表
  /// </summary>
  /// <param name="objFile">待签名的文件</param>
  /// <param name="HashData">Hash描述</param>
  /// <returns></returns>
  public bool GetHash(System.IO.FileStream objFile, ref byte[] HashData)
  {
      try
      {
          //从文件中取得Hash描述 
          System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
          HashData = MD5.ComputeHash(objFile);
          objFile.Close();
          return true;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }

  /// <summary>
  /// 获取Hash描述表
  /// </summary>
  /// <param name="objFile">待签名的文件</param>
  /// <param name="strHashData">Hash描述</param>
  /// <returns></returns>
  public bool GetHash(System.IO.FileStream objFile, ref string strHashData)
  {
      try
      {
          //从文件中取得Hash描述 
          byte[] HashData;
          System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
          HashData = MD5.ComputeHash(objFile);
          objFile.Close();
          strHashData = Convert.ToBase64String(HashData);
          return true;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }
  #endregion

  #region RSA签名

  /// <summary>
  /// RSA签名(新增)
  /// </summary>
  /// <param name="data"></param>
  /// <param name="str_PrivateKey"></param>
  /// <returns></returns>
  public string Signature(string data, string strKeyPrivate)
  {
      //生成对应Pkcs1的密钥   Pkcs12,Pkcs8需先转成kcs1
      System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

      RSA.FromXmlString(strKeyPrivate);

      byte[] dataBytes = Encoding.UTF8.GetBytes(data);

      var signatureBytes = RSA.SignData(dataBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);

      return Convert.ToBase64String(signatureBytes);
  }
  /// <summary>
  /// RSA签名
  /// </summary>
  /// <param name="strKeyPrivate">私钥</param>
  /// <param name="HashbyteSignature">待签名Hash描述</param>
  /// <param name="EncryptedSignatureData">签名后的结果</param>
  /// <returns></returns>
  public bool Signature(string strKeyPrivate, byte[] HashbyteSignature, ref byte[] EncryptedSignatureData)
  {
      try
      {
          System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

          RSA.FromXmlString(strKeyPrivate);
          System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter(RSA);
          //设置签名的算法为MD5 
          RSAFormatter.SetHashAlgorithm("MD5");
          //执行签名 
          EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);
          return true;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }

  /// <summary>
  /// RSA签名
  /// </summary>
  /// <param name="strKeyPrivate">私钥</param>
  /// <param name="HashbyteSignature">待签名Hash描述</param>
  /// <param name="m_strEncryptedSignatureData">签名后的结果</param>
  /// <returns></returns>
  public bool Signature(string strKeyPrivate, byte[] HashbyteSignature, ref string strEncryptedSignatureData)
  {
      try
      {
          byte[] EncryptedSignatureData;
          System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
          RSA.FromXmlString(strKeyPrivate);
          System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter(RSA);
          //设置签名的算法为MD5 
          RSAFormatter.SetHashAlgorithm("MD5");
          //执行签名 
          EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);
          strEncryptedSignatureData = Convert.ToBase64String(EncryptedSignatureData);
          return true;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }

  /// <summary>
  /// RSA签名
  /// </summary>
  /// <param name="strKeyPrivate">私钥</param>
  /// <param name="strHashbyteSignature">待签名Hash描述</param>
  /// <param name="EncryptedSignatureData">签名后的结果</param>
  /// <returns></returns>
  public bool Signature(string strKeyPrivate, string strHashbyteSignature, ref byte[] EncryptedSignatureData)
  {
      try
      {
          byte[] HashbyteSignature;

          HashbyteSignature = Convert.FromBase64String(strHashbyteSignature);
          System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

          RSA.FromXmlString(strKeyPrivate);
          System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter(RSA);
          //设置签名的算法为MD5 
          RSAFormatter.SetHashAlgorithm("MD5");
          //执行签名 
          EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);

          return true;
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }

  /// <summary>
  /// RSA签名
  /// </summary>
  /// <param name="strKeyPrivate">私钥</param>
  /// <param name="strHashbyteSignature">待签名Hash描述</param>
  /// <param name="strEncryptedSignatureData">签名后的结果</param>
  /// <returns></returns>
  public bool Signature(string strKeyPrivate, string strHashbyteSignature, ref string strEncryptedSignatureData)
  {
      //try
      //{
      byte[] HashbyteSignature;
      byte[] EncryptedSignatureData;
      HashbyteSignature = Convert.FromBase64String(strHashbyteSignature);
      System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
      RSA.FromXmlString(strKeyPrivate);
      System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter(RSA);
      //设置签名的算法为MD5 
      RSAFormatter.SetHashAlgorithm("MD5");
      //执行签名 
      EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);
      strEncryptedSignatureData = Convert.ToBase64String(EncryptedSignatureData);
      return true;
      //}
      //catch (Exception ex)
      //{
      //    throw ex;
      //}
  }
  #endregion

  #region RSA 签名验证
  /// <summary>
  /// 公钥验签（新增,不需要Hash描述）
  /// </summary>
  /// <param name="data">原始数据</param>
  /// <param name="sign">签名</param>
  /// <returns></returns>
  public bool VerifySign(string data, string sign, string publicKeyString)
  {
      byte[] dataBytes = Encoding.UTF8.GetBytes(data);
      byte[] signBytes = Convert.FromBase64String(sign);
      System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

      RSA.FromXmlString(publicKeyString);
      var verify = RSA.VerifyData(dataBytes, signBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);

      return verify;
  }
  /// <summary>
  /// RSA签名验证
  /// </summary>
  /// <param name="strKeyPublic">公钥</param>
  /// <param name="HashbyteDeformatter">Hash描述</param>
  /// <param name="DeformatterData">签名后的结果</param>
  /// <returns></returns>
  public bool VerifySignature(string strKeyPublic, byte[] HashbyteDeformatter, byte[] DeformatterData)
  {
      try
      {
          System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
          RSA.FromXmlString(strKeyPublic);
          System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
          //指定解密的时候HASH算法为MD5 
          RSADeformatter.SetHashAlgorithm("MD5");
          if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
          {
              return true;
          }
          else
          {
              return false;
          }
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }
  /// <summary>
  /// RSA签名验证
  /// </summary>
  /// <param name="strKeyPublic">公钥</param>
  /// <param name="strHashbyteDeformatter">Hash描述</param>
  /// <param name="DeformatterData">签名后的结果</param>
  /// <returns></returns>
  public bool VerifySignature(string strKeyPublic, string strHashbyteDeformatter, byte[] DeformatterData)
  {
      try
      {
          byte[] HashbyteDeformatter;
          HashbyteDeformatter = Convert.FromBase64String(strHashbyteDeformatter);
          System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
          RSA.FromXmlString(strKeyPublic);
          System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
          //指定解密的时候HASH算法为MD5 
          RSADeformatter.SetHashAlgorithm("MD5");
          if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
          {
              return true;
          }
          else
          {
              return false;
          }
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }
  /// <summary>
  /// RSA签名验证
  /// </summary>
  /// <param name="strKeyPublic">公钥</param>
  /// <param name="HashbyteDeformatter">Hash描述</param>
  /// <param name="strDeformatterData">签名后的结果</param>
  /// <returns></returns>
  public bool VerifySignature(string strKeyPublic, byte[] HashbyteDeformatter, string strDeformatterData)
  {
      try
      {
          byte[] DeformatterData;
          System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
          RSA.FromXmlString(strKeyPublic);
          System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
          //指定解密的时候HASH算法为MD5 
          RSADeformatter.SetHashAlgorithm("MD5");
          DeformatterData = Convert.FromBase64String(strDeformatterData);
          if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
          {
              return true;
          }
          else
          {
              return false;
          }
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }
  /// <summary>
  /// RSA签名验证
  /// </summary>
  /// <param name="strKeyPublic">公钥</param>
  /// <param name="strHashbyteDeformatter">Hash描述</param>
  /// <param name="strDeformatterData">签名后的结果</param>
  /// <returns></returns>
  public bool VerifySignature(string strKeyPublic, string strHashbyteDeformatter, string strDeformatterData)
  {
      try
      {
          byte[] DeformatterData;
          byte[] HashbyteDeformatter;
          HashbyteDeformatter = Convert.FromBase64String(strHashbyteDeformatter);
          System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
          RSA.FromXmlString(strKeyPublic);
          System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
          //指定解密的时候HASH算法为MD5 
          RSADeformatter.SetHashAlgorithm("MD5");
          DeformatterData = Convert.FromBase64String(strDeformatterData);
          if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
          {
              return true;
          }
          else
          {
              return false;
          }
      }
      catch (Exception ex)
      {
          throw ex;
      }
  }
  #endregion

  #endregion

}

自动生成xml格式私钥、公钥

var rsa = new RSACryption();
//生成私钥、公钥
rsa.RSAKey(out string privateKey, out string publicKey);
string content = "加密内容";
//加密
string crypto = rsa.RSAEncrypt(publicKey, content);
//解密
content = rsa.RSADecrypt(privateKey, crypto);


//签名
string hashData = null,signature = null;
rsa.GetHash(content, ref hashData);
rsa.Signature(privateKey, hashData, ref signature);
//验签
bool success = rsa.VerifySignature(publicKey, hashData, signature);

将pem格式私钥公钥转换成xml格式

            string publicKey = @"-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqnl/mT/16QTUAxjHWAX7
RTi/tZucMi5qo1hxOPYyng15tevRWf/IPPZMHbFaqtpZfU4KV6GOW/+j5ZhB0lsH
AKE1MKxE/u0OZEyQI/16ayIOrcDrKJCdB5msdFlfOnwsVqswxVPCtb1Srv9U0mlY
3RBzxGsldEdG0L6hNGp16QXtJ8bSBJq3h3yY9sQ6XcznXrk+SgzytpwQZw3nff5m
K8DNMU7/THQ6knoR0pkF5gS+30T2lTqKUuGNfvfrknCb4Ejl5EksMOj1Fi+KjpMC
nuuh5LNZZUEhCb++nSStqT9uT7dNcCgjrfzTGaC0VGTefwM1t8Ste0o3VP7/IAt0
sQIDAQAB
-----END PUBLIC KEY-----
            ";
            string privateKey = @"-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEAqnl/mT/16QTUAxjHWAX7RTi/tZucMi5qo1hxOPYyng15tevR
Wf/IPPZMHbFaqtpZfU4KV6GOW/+j5ZhB0lsHAKE1MKxE/u0OZEyQI/16ayIOrcDr
KJCdB5msdFlfOnwsVqswxVPCtb1Srv9U0mlY3RBzxGsldEdG0L6hNGp16QXtJ8bS
BJq3h3yY9sQ6XcznXrk+SgzytpwQZw3nff5mK8DNMU7/THQ6knoR0pkF5gS+30T2
lTqKUuGNfvfrknCb4Ejl5EksMOj1Fi+KjpMCnuuh5LNZZUEhCb++nSStqT9uT7dN
cCgjrfzTGaC0VGTefwM1t8Ste0o3VP7/IAt0sQIDAQABAoIBAQCdG2f65jVNUMPL
LtTYTHrrqocTaZujq59fdqyx4EN54dVfUTsZBF+Xvy0a2E5E0wJSNs/VPvCh3JFB
kPZoVLe5XthUSQ81GWeADAdzA7IEdditTPPr6IqvbHLAr3TRw4phPVevI6h4MUi4
OlwDpk7dPMJULKLR7LZYvrZ2Rf7whqG2SqEdJxb6NqMlMBFRzcAP+qFvu+DZNZTP
hMyOKst40Q/zwAcEMQ3UodVWNqVvzDSCe0/YQMSuhnKiIhF+4ef+Melzv1uSBkxr
TPpP+mQsSjIOO2vPhIO32H70KzBbImtLvoi9FaSrzfSNmJ19vOdtn3on5lnVZrti
0Sw5+6uBAoGBAN/W16gD2nfgFhdOhTWWR8tRPEvPK3eK0v8h0esN7OPDxS4Hv5v5
ntBiZXSYJJjQOKTyv+tjh803nE4YawQZXgJigoSltILfD/a5A2Hw6ItEcd+uQIUm
Ca7KMmRqNE2va2rPvdxJbyDiLdH54lBAPmZjdUXHGGhSULFC9C3fC21ZAoGBAML3
0k1T8+7YOuuAx7W0nIp1qQWpgfvvALYJA7+pTNEVdL9uZO5wu2pZp1YDEu605aQ3
aDy18mXUS6BB6vnl69JUcOPI6BiPEd+CTgSRM5mDZJ2DdO5lEu4fY5294MiFylKQ
rMxorEVX/eXwmPw/6naa3kI9DKoW6FiENaF9MB8ZAoGBAKnZ2vcRRXvlPJ4e5RIO
oRf04q4b3D3vx7/1p9aXUIRcj4koNAtlVU+G+rmIoWybw//WfC9f7TKZ2i+gc8Q+
g4mHusZw/xK3tONg7OIq7iqPm2FCVo8yl/JcV/S+akXwsK/yR32a84qeVmqZFVQU
C8Wh/uEd/LVckQKRbbxJHeCxAoGAc7T7vCSsyfzNyuIco7vSg2Gcs92LZObMtzvW
W7KwAg4HwWxUviVtNIqMgsFERSJafwDa/dzFRKWfVDaKq1BGigbPEIA1Lg4Kf2kn
wBIkW2DdH5XamXimqWc7iWwcsSSllCaERrOAOY8lAYeuY1XTYhw693ifwXni3lVo
NrTDEFECgYB/J86p5e9c8L3pMdz/jmXfMfefekaO+uf6QemnUcaXyWJAE9dmLXV3
efv946taItA9D7iRv4Ww4HyKaH2irYHaNUDXfYSKZ9xM/15who9qSklcPmZ9EUYY
VlESrKuD5bx/mbtyFVkJ3OmvxTrS/E04QaMarfbUSnm5LfE0zuXNbw==
-----END RSA PRIVATE KEY-----

";
privateKey = RSACryption.PemPrivateKeyToXml(privateKey);
publicKey = RSACryption.PemPublicKeyToXml(publicKey);
string content = "加密内容";
//加密
string crypto = rsa.RSAEncrypt(publicKey, content);
//解密
content = rsa.RSADecrypt(privateKey, crypto);