带传输的C#RSA加密/解密

我在网上看到了大量使用System.Security.Cryptography.RSACryptServiceProvider的C#加密/解密教程和示例，但我希望能够做到：

• 创建RSA公钥/私钥对
• 传输公钥（或者为了概念验证，只需在字符串变量中移动它）
• 创建新的RSA加密提供程序并使用公钥加密字符串
• 将加密字符串（或数据）传输回原始加密提供程序并解密该字符串

---

有人能给我指出一个有用的资源吗？

关于这一点，确实有足够的例子，但不管怎样，给你

using System;
using System.Security.Cryptography;

namespace RsaCryptoExample
{
  static class Program
  {
    static void Main()
    {
      //lets take a new CSP with a new 2048 bit rsa key pair
      var csp = new RSACryptoServiceProvider(2048);

      //how to get the private key
      var privKey = csp.ExportParameters(true);

      //and the public key ...
      var pubKey = csp.ExportParameters(false);

      //converting the public key into a string representation
      string pubKeyString;
      {
        //we need some buffer
        var sw = new System.IO.StringWriter();
        //we need a serializer
        var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
        //serialize the key into the stream
        xs.Serialize(sw, pubKey);
        //get the string from the stream
        pubKeyString = sw.ToString();
      }

      //converting it back
      {
        //get a stream from the string
        var sr = new System.IO.StringReader(pubKeyString);
        //we need a deserializer
        var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
        //get the object back from the stream
        pubKey = (RSAParameters)xs.Deserialize(sr);
      }

      //conversion for the private key is no black magic either ... omitted

      //we have a public key ... let's get a new csp and load that key
      csp = new RSACryptoServiceProvider();
      csp.ImportParameters(pubKey);

      //we need some data to encrypt
      var plainTextData = "foobar";

      //for encryption, always handle bytes...
      var bytesPlainTextData = System.Text.Encoding.Unicode.GetBytes(plainTextData);

      //apply pkcs#1.5 padding and encrypt our data 
      var bytesCypherText = csp.Encrypt(bytesPlainTextData, false);

      //we might want a string representation of our cypher text... base64 will do
      var cypherText = Convert.ToBase64String(bytesCypherText);


      /*
       * some transmission / storage / retrieval
       * 
       * and we want to decrypt our cypherText
       */

      //first, get our bytes back from the base64 string ...
      bytesCypherText = Convert.FromBase64String(cypherText);

      //we want to decrypt, therefore we need a csp and load our private key
      csp = new RSACryptoServiceProvider();
      csp.ImportParameters(privKey);

      //decrypt and strip pkcs#1.5 padding
      bytesPlainTextData = csp.Decrypt(bytesCypherText, false);

      //get our original plainText back...
      plainTextData = System.Text.Encoding.Unicode.GetString(bytesPlainTextData);
    }
  }
}

作为旁注：对Encrypt（）和Decrypt（）的调用有一个bool参数，用于在OAEP和PKCS#1.5填充之间切换。。。如果OAEP在您的情况下可用，您可能需要选择它

公共静态字符串加密（string strText）
public static string Encryption(string strText)
        {
            var publicKey = "<RSAKeyValue><Modulus>21wEnTU+mcD2w0Lfo1Gv4rtcSWsQJQTNa6gio05AOkV/Er9w3Y13Ddo5wGtjJ19402S71HUeN0vbKILLJdRSES5MHSdJPSVrOqdrll/vLXxDxWs/U0UT1c8u6k/Ogx9hTtZxYwoeYqdhDblof3E75d9n2F0Zvf6iTb4cI7j6fMs=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";

            var testData = Encoding.UTF8.GetBytes(strText);

            using (var rsa = new RSACryptoServiceProvider(1024))
            {
                try
                {
                    // client encrypting data with public key issued by server                    
                    rsa.FromXmlString(publicKey.ToString());

                    var encryptedData = rsa.Encrypt(testData, true);

                    var base64Encrypted = Convert.ToBase64String(encryptedData);

                    return base64Encrypted;
                }
                finally
                {
                    rsa.PersistKeyInCsp = false;
                }
            }
        }

        public static string Decryption(string strText)
        {
            var privateKey = "<RSAKeyValue><Modulus>21wEnTU+mcD2w0Lfo1Gv4rtcSWsQJQTNa6gio05AOkV/Er9w3Y13Ddo5wGtjJ19402S71HUeN0vbKILLJdRSES5MHSdJPSVrOqdrll/vLXxDxWs/U0UT1c8u6k/Ogx9hTtZxYwoeYqdhDblof3E75d9n2F0Zvf6iTb4cI7j6fMs=</Modulus><Exponent>AQAB</Exponent><P>/aULPE6jd5IkwtWXmReyMUhmI/nfwfkQSyl7tsg2PKdpcxk4mpPZUdEQhHQLvE84w2DhTyYkPHCtq/mMKE3MHw==</P><Q>3WV46X9Arg2l9cxb67KVlNVXyCqc/w+LWt/tbhLJvV2xCF/0rWKPsBJ9MC6cquaqNPxWWEav8RAVbmmGrJt51Q==</Q><DP>8TuZFgBMpBoQcGUoS2goB4st6aVq1FcG0hVgHhUI0GMAfYFNPmbDV3cY2IBt8Oj/uYJYhyhlaj5YTqmGTYbATQ==</DP><DQ>FIoVbZQgrAUYIHWVEYi/187zFd7eMct/Yi7kGBImJStMATrluDAspGkStCWe4zwDDmdam1XzfKnBUzz3AYxrAQ==</DQ><InverseQ>QPU3Tmt8nznSgYZ+5jUo9E0SfjiTu435ihANiHqqjasaUNvOHKumqzuBZ8NRtkUhS6dsOEb8A2ODvy7KswUxyA==</InverseQ><D>cgoRoAUpSVfHMdYXW9nA3dfX75dIamZnwPtFHq80ttagbIe4ToYYCcyUz5NElhiNQSESgS5uCgNWqWXt5PnPu4XmCXx6utco1UVH8HGLahzbAnSy6Cj3iUIQ7Gj+9gQ7PkC434HTtHazmxVgIR5l56ZjoQ8yGNCPZnsdYEmhJWk=</D></RSAKeyValue>";

            var testData = Encoding.UTF8.GetBytes(strText);

            using (var rsa = new RSACryptoServiceProvider(1024))
            {
                try
                {                    
                    var base64Encrypted = strText;

                    // server decrypting data with private key                    
                    rsa.FromXmlString(privateKey);

                    var resultBytes = Convert.FromBase64String(base64Encrypted);
                    var decryptedBytes = rsa.Decrypt(resultBytes, true);
                    var decryptedData = Encoding.UTF8.GetString(decryptedBytes);
                    return decryptedData.ToString();
                }
                finally
                {
                    rsa.PersistKeyInCsp = false;
                }
            }
        }

{
var publicKey=“21wEnTU+MCD2W0LFO1GV4RTCSWSSQJQTNA6GIO05AOKV/Er9w3Y13Ddo5wGtjJ19402S71HUeN0vbKILLJdRSES5MHSdJPSVrOqdrll/vLXxDxWs/U0UT1c8u6k/OGX9HTTZXYWOEQDHDBLOF3E75D9N2F0ZVF6ITB4CI7J6FMS=AQAB”；
var testData=Encoding.UTF8.GetBytes（strText）；
使用（var rsa=new RSACryptoServiceProvider（1024））
{
尝试
{
//客户端使用服务器颁发的公钥加密数据
rsa.FromXmlString（publicKey.ToString（））；
var encryptedData=rsa.Encrypt（testData，true）；
var base64Encrypted=Convert.ToBase64String（encryptedData）；
返回base64加密；
}
最后
{
rsa.PersistKeyInCsp=false；
}
}
}
公共静态字符串解密（字符串strText）
{
var privateKey="2.文中给出了一个简单的数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，这个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个数字，一个CF/0rWKPsBJ9MC6cquaqNPxWWEav8RAVbm（8）管理者（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q（8）Q）Q（8）Q（8）Q（8）Q）Q（8）Q（8）Q）Q（8）Q（8）Q（8）Q（8）Q）Q（8）Q（8）Q（8）Q）Q（8）Q（8）G（8）G（8）Q）G（8）G（8）Q）G（8）G（8）B）G）是一）是一（8）是一个（7）是一个中国政府的一个（7）是一个（7）是一个（7）是一个（7）是一个（7）是一个（7）是一个（7）是一个（7）的，一个LHINQSESGS5UCGNwqwxt5pnpu4xmcxx6utco1uvh8glahzbansy6cj3iuiq7gj+9gQ7PkC434HTtHazmxVgIR5l56ZjoQ8yGNCPZnsdYEmhJWk=“；
var testData=Encoding.UTF8.GetBytes（strText）；
使用（var rsa=new RSACryptoServiceProvider（1024））
{
尝试
{                    
var base64Encrypted=strText；
//服务器使用私钥解密数据
rsa.FromXmlString（privateKey）；
var resultBytes=Convert.FromBase64String（base64Encrypted）；
var decryptedBytes=rsa.Decrypt（resultBytes，true）；
var decryptedData=Encoding.UTF8.GetString（decryptedBytes）；
返回decryptedData.ToString（）；
}
最后
{
rsa.PersistKeyInCsp=false；
}
}
}

老实说，我很难实现它，因为我搜索过的教程中几乎没有显示将密钥写入文件的内容。公认的答案是“很好”“。但对我来说，我必须改进它，以便将两个密钥保存到两个单独的文件中。我已经写了一个助手类，所以你们只需要复制并粘贴它。希望这对lol有帮助

using Microsoft.Win32;
using System;
using System.IO;
using System.Security.Cryptography;

namespace RsaCryptoExample
{
    class RSAFileHelper
    {
        readonly string pubKeyPath = "public.key";//change as needed
        readonly string priKeyPath = "private.key";//change as needed
        public void MakeKey()
        {
            //lets take a new CSP with a new 2048 bit rsa key pair
            RSACryptoServiceProvider csp = new RSACryptoServiceProvider(2048);

            //how to get the private key
            RSAParameters privKey = csp.ExportParameters(true);

            //and the public key ...
            RSAParameters pubKey = csp.ExportParameters(false);
            //converting the public key into a string representation
            string pubKeyString;
            {
                //we need some buffer
                var sw = new StringWriter();
                //we need a serializer
                var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
                //serialize the key into the stream
                xs.Serialize(sw, pubKey);
                //get the string from the stream
                pubKeyString = sw.ToString();
                File.WriteAllText(pubKeyPath, pubKeyString);
            }
            string privKeyString;
            {
                //we need some buffer
                var sw = new StringWriter();
                //we need a serializer
                var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
                //serialize the key into the stream
                xs.Serialize(sw, privKey);
                //get the string from the stream
                privKeyString = sw.ToString();
                File.WriteAllText(priKeyPath, privKeyString);
            }
        }
        public void EncryptFile(string filePath)
        {
            //converting the public key into a string representation
            string pubKeyString;
            {
                using (StreamReader reader = new StreamReader(pubKeyPath)){pubKeyString = reader.ReadToEnd();}
            }
            //get a stream from the string
            var sr = new StringReader(pubKeyString);

            //we need a deserializer
            var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));

            //get the object back from the stream
            RSACryptoServiceProvider csp = new RSACryptoServiceProvider();
            csp.ImportParameters((RSAParameters)xs.Deserialize(sr));
            byte[] bytesPlainTextData = File.ReadAllBytes(filePath);

            //apply pkcs#1.5 padding and encrypt our data 
            var bytesCipherText = csp.Encrypt(bytesPlainTextData, false);
            //we might want a string representation of our cypher text... base64 will do
            string encryptedText = Convert.ToBase64String(bytesCipherText);
            File.WriteAllText(filePath,encryptedText);
        }
        public void DecryptFile(string filePath)
        {
            //we want to decrypt, therefore we need a csp and load our private key
            RSACryptoServiceProvider csp = new RSACryptoServiceProvider();

            string privKeyString;
            {
                privKeyString = File.ReadAllText(priKeyPath);
                //get a stream from the string
                var sr = new StringReader(privKeyString);
                //we need a deserializer
                var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
                //get the object back from the stream
                RSAParameters privKey = (RSAParameters)xs.Deserialize(sr);
                csp.ImportParameters(privKey);
            }
            string encryptedText;
            using (StreamReader reader = new StreamReader(filePath)) { encryptedText = reader.ReadToEnd(); }
            byte[] bytesCipherText = Convert.FromBase64String(encryptedText);

            //decrypt and strip pkcs#1.5 padding
            byte[] bytesPlainTextData = csp.Decrypt(bytesCipherText, false);

            //get our original plainText back...
            File.WriteAllBytes(filePath, bytesPlainTextData);
        }
    }
}

---

出于示例目的，我将分享我的非常简单的代码。希望它能帮助像我这样的人搜索快速代码参考。 我的目标是从后端接收rsa签名，然后使用公钥对输入字符串进行验证，并在本地存储以备将来的定期验证。 以下是用于签名验证的主要部分：

        ...
        var signature = Get(url); // base64_encoded signature received from server
        var inputtext= "inputtext"; // this is main text signature was created for
        bool result = VerifySignature(inputtext, signature);
        ...

    private bool VerifySignature(string input, string signature)
    {
        var result = false;
        using (var cps=new RSACryptoServiceProvider())
        {
            // converting input and signature to Bytes Arrays to pass to VerifyData rsa method to verify inputtext was signed using privatekey corresponding to public key we have below
            byte[] inputtextBytes = Encoding.UTF8.GetBytes(input);
            byte[] signatureBytes  = Convert.FromBase64String(signature);

            cps.FromXmlString("<RSAKeyValue><Modulus>....</Modulus><Exponent>....</Exponent></RSAKeyValue>"); // xml formatted publickey
            result = cps.VerifyData(inputtextBytes , new SHA1CryptoServiceProvider(), signatureBytes  );
        }

        return result;
    }

。。。
var signature=Get（url）；//从服务器接收的base64_编码签名
var inputtext=“inputtext”//这是为创建的主文本签名
bool结果=验证签名（输入文本，签名）；
...
私有布尔验证签名（字符串输入，字符串签名）
{
var结果=假；
使用（var cps=new rsacryptserviceprovider（））
{
//将输入和签名转换为字节数组以传递给VerifyData rsa方法，以验证inputtext是使用与下面的公钥对应的privatekey签名的
byte[]inputExtBytes=Encoding.UTF8.GetBytes（输入）；
byte[]signatureBytes=Convert.FromBase64String（签名）；
cps.FromXmlString（“…”）；//xml格式的公钥
结果=cps.VerifyData（InputExtBytes，新的SHA1CryptoServiceProvider（），signatureBytes）；
}
返回结果；
}

您能否指出一个具体的教程，该教程解释了C#中RSA的加密和解密，但没有满足您的具体需求？我得说它们很直截了当，从你的问题来看，我不清楚你对哪一部分有问题。非常感谢你，先生！我会投票给你，但我需要15个代表。当我这样做的时候，我会记住你的！：）@传输：如果它回答你的问题，请考虑接受答案。有没有算法可以在保证相同安全性的同时缩短它？（最好只包含数字和大写字母）@Sepherm RSA不打算加密大量数据。。。你应该考虑使用对称C。