C# RSAHelper

 

using

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;

 

Helper

/// <summary>
    /// RSA帮助类
    /// </summary>
    public class RSAHelper
    {
        /// <summary>
        /// 生成密钥
        /// </summary>
        /// <param name="privarteKey"></param>
        /// <param name="publicKey"></param>
        /// <param name="keySize"></param>
        public static void Generator(out string privarteKey, out string publicKey, int keySize = 1024)
        {
            RSACryptoServiceProvider rea = new RSACryptoServiceProvider(keySize);
            privarteKey = rea.ToXmlString(true);
            publicKey = rea.ToXmlString(false);
        }

        /// <summary>
        /// RSA加密数据
        /// </summary>
        /// <param name="content">要加密数据</param>
        /// <param name="publickey">密匙容器的名称</param>
        /// <returns></returns>
        public static string RSAEncryption(string content, string publickey)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            byte[] cipherbytes;
            rsa.FromXmlString(publickey);
            cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(content), false);
            return Convert.ToBase64String(cipherbytes);
        }

        /// <summary>
        /// RSA解密数据
        /// </summary>
        /// <param name="content">要解密数据</param>
        /// <param name="privatekey">密匙容器的名称</param>
        /// <returns></returns>
        public static string RSADecrypt(string content, string privatekey)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            byte[] cipherbytes;
            rsa.FromXmlString(privatekey);
            cipherbytes = rsa.Decrypt(Convert.FromBase64String(content), false);

            return Encoding.UTF8.GetString(cipherbytes);
        }

        /// <summary>
        /// 生成数字签名
        /// </summary>
        /// <param name="originalText">原文</param>
        /// <param name="privateKey"></param>
        /// <returns></returns>
        public static string GenSign(string originalText, string privateKey)
        {
            byte[] byteData = Encoding.UTF8.GetBytes(originalText);
            RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
            provider.FromXmlString(privateKey);
            //使用SHA1进行摘要算法，生成签名
            byteData = provider.SignData(byteData, new SHA1CryptoServiceProvider());
            return Convert.ToBase64String(byteData);
        }

        /// <summary>
        /// 验证签名
        /// </summary>
        /// <param name="originalText">原文</param>
        /// <param name="signedData">签名</param>
        /// <param name="publicKey">公钥</param>
        /// <returns></returns>
        public static bool VerifySigned(string originalText, string signedData, string publicKey)
        {
            RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
            provider.FromXmlString(publicKey);
            byte[] byteData = Encoding.UTF8.GetBytes(originalText);
            byte[] signData = Convert.FromBase64String(signedData);
            return provider.VerifyData(byteData, new SHA1CryptoServiceProvider(), signData);
        }

        /// <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;
        }
    }

 

Test

string privateKey = @"<RSAKeyValue><Modulus>yraVpjSjZtR0n44cUhZanc2T7FznFi/NyjtSG1WlghJr0zelQeciBQk0Cm+fO8rAh/5s+pHRk7UEOrQ9CJEClbxgR/w3zavSo7rF2TT5wC/fHL3083mpZU6540n6afl5IvrSGuXimK3RrM20mBotwXurFVnYDx3nAOK2UDo6H8E=</Modulus><Exponent>AQAB</Exponent><P>z3mjaVsCC4m7NU8ejEdsPJTdoWhAXiRBwoRH+rYYywOn+3xUKdy+gfJM92m7taTQVJXOKktEISVOpOWVkkxKdw==</P><Q>+h/UpRfKNsMf24TRQwQT1807iBeZw95GXiiUZB9PVLN+4n9hcovPndwhgRLSVK3jfkKDsf/TocGcGUIy82O9hw==</Q><DP>oHxQwQAatt4VJ4lJ8eyVds8YGPBRSgD1tQcpvm75AqCTYd6sI62S12Wbz43EGx+f3q36SZDq5FC9YqQMbJwCxQ==</DP><DQ>PkNSMc6cPcmQ0ppbZS1Mqzmhih0l38YjCilb1xicLN+JxGQlI9h91DQJ+xFuXjnzGWkBU3v1eJyzeO4rtL6tXQ==</DQ><InverseQ>jGlm3ypBpIN0l5ys+HSjTYC/UIYPEm745+WXtczcVDtyYcASsjUETE/8yUhA8m349aan04HDtfsEAVZNeB/Z1Q==</InverseQ><D>qjICEzm+t2dJQ20deg4qprMjrx+RJZ+dOF314d1WyI6O2RevOFXGylOfzeNJ3fmtDIEhHn+vZkRk+KS7WaXmdDExmwIWlcjy+jc1VLB6THjHzWmnp09gWfOAHH7w40zhAbt0hjXasWHqdzs1gb0uPZmw21FeOY+90tl+kZGTH8E=</D></RSAKeyValue>";

string publicKey = @"<RSAKeyValue><Modulus>yraVpjSjZtR0n44cUhZanc2T7FznFi/NyjtSG1WlghJr0zelQeciBQk0Cm+fO8rAh/5s+pHRk7UEOrQ9CJEClbxgR/w3zavSo7rF2TT5wC/fHL3083mpZU6540n6afl5IvrSGuXimK3RrM20mBotwXurFVnYDx3nAOK2UDo6H8E=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";

//生成秘钥对
RSAHelper.Generator(out privateKey, out publicKey, 512);

//需要加密的内容
var content = "323";
//密文
var enContent = RSAHelper.RSAEncryption(content, publicKey);
//解密内容
var desContent = RSAHelper.RSADecrypt(enContent, privateKey);
//签名，用是私钥
var sign = RSAHelper.GenSign(enContent, privateKey);
//验证签名
var bbb = RSAHelper.VerifySigned(enContent, sign, publicKey);

var privateKeyToPem = RSAHelper.XmlPrivateKeyToPem(privateKey);

var publicKeyToPem = RSAHelper.XmlPublicKeyToPem(publicKey);

var privateKeyToXml = RSAHelper.PemPrivateKeyToXml(privateKeyToPem);

var publicKeyToXml = RSAHelper.PemPublicKeyToXml(publicKeyToPem);

 

直接使用