.net core 常用rsa 加签类

using Org.BouncyCastle.Crypto;

using Org.BouncyCastle.Crypto.Parameters;

using Org.BouncyCastle.Math;

using Org.BouncyCastle.OpenSsl;

using Org.BouncyCastle.Pkcs;

using Org.BouncyCastle.Security;

using Org.BouncyCastle.X509;

using System;

using System.Collections.Generic;

using System.IO;

using System.Security.Cryptography;

using System.Text;

using System.Xml;

using System.Xml.Linq;

namespace Payment.LianLianPay.Sdk.Infrastructure

{

    public static class RsaHelper

    {

        /// <summary>

        /// private key sign

        /// </summary>

        /// <param name="preSign"></param>

        /// <param name="isJavaFormatKey"></param>

        /// <param name="privateKey"></param>

        /// <returns></returns>

        public static string RsaSign(string preSign, bool isJavaFormatKey, string privateKey)

        {

            try

            {

                //// net

                //var rsa = new RSACryptoServiceProvider();

                //rsa.FromXmlString(privateKey);

                //byte[] signBytes = rsa.SignData(UTF8Encoding.UTF8.GetBytes(signStr), "md5");

                //return Convert.ToBase64String(signBytes);

                // net core 2.0

                using (var rsa = RSA.Create())

                {

                    if (isJavaFormatKey) privateKey = RsaPrivateKeyJava2DotNet(privateKey);

                    rsa.FromXmlStringExtensions(privateKey);

                    var bytes = rsa.SignData(Encoding.UTF8.GetBytes(preSign), HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);

                    return Convert.ToBase64String(bytes);

                }

            }

            catch (Exception e)

            {

                throw new ArgumentException(e.Message);

            }

        }

        /// <summary>

        /// .net => java Md5WithRsa

        /// </summary>

        /// <param name="preSign"></param>

        /// <param name="isJavaFormatKey"></param>

        /// <param name="privateKey"></param>

        /// <returns></returns>

        public static string RsaSignMd5WithRsa(string preSign, bool isJavaFormatKey, string privateKey)

        {

            try

            {

                //// net

                //var rsa = new RSACryptoServiceProvider();

                //rsa.FromXmlString(privateKey);

                //byte[] signBytes = rsa.SignData(UTF8Encoding.UTF8.GetBytes(signStr), "md5");

                //return Convert.ToBase64String(signBytes);

                // net core 2.0

                using (var rsa = RSA.Create())

                {

                    if (isJavaFormatKey) privateKey = RsaPrivateKeyJava2DotNet(privateKey);

                    rsa.FromXmlStringExtensions(privateKey);

                    var bytes = rsa.SignData(Encoding.UTF8.GetBytes(preSign), HashAlgorithmName.MD5, RSASignaturePadding.Pkcs1);

                    return Convert.ToBase64String(bytes);

                }

            }

            catch (Exception e)

            {

                throw new ArgumentException(e.Message);

            }

        }

        /// <summary>

        /// public key sign

        /// </summary>

        /// <param name="preSign"></param>

        /// <param name="publicKey"></param>

        /// <returns></returns>

        public static string RsaEncrypt(string preSign, string publicKey)

        {

            try

            {

                //// net

                //RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

                //rsa.FromXmlString(strPublicKey);

                //byte[] bytes = rsa.Encrypt(UTF8Encoding.UTF8.GetBytes(strEncryptInfo), false);

                //return Convert.ToBase64String(bytes);

                // net core 2.0

                using (var rsa = RSA.Create())

                {

                    publicKey = RsaPublicKeyJava2DotNet(publicKey);

                    rsa.FromXmlStringExtensions(publicKey);

                    var bytes = rsa.Encrypt(Encoding.UTF8.GetBytes(preSign), RSAEncryptionPadding.Pkcs1);

                    return Convert.ToBase64String(bytes);

                }

            }

            catch (Exception e)

            {

                throw new ArgumentException(e.Message);

            }

        }

        /// <summary>

        /// public key validate

        /// </summary>

        /// <param name="preSign"></param>

        /// <param name="isJavaFormatKey"></param>

        /// <param name="publicKey"></param>

        /// <param name="signedData"></param>

        /// <returns></returns>

        public static bool ValidateRsaSign(string preSign, bool isJavaFormatKey, string publicKey, string signedData)

        {

            try

            {

                //// net

                //RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

                //rsa.FromXmlString(publicKey);

                //return rsa.VerifyData(UTF8Encoding.UTF8.GetBytes(plainText), "md5", Convert.FromBase64String(signedData));

                // net core 2.0

                using (var rsa = RSA.Create())

                {

                    if (isJavaFormatKey) publicKey = RsaPublicKeyJava2DotNet(publicKey);

                    rsa.FromXmlStringExtensions(publicKey);

                    return rsa.VerifyData(Encoding.UTF8.GetBytes(preSign), Convert.FromBase64String(signedData), HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);

                }

            }

            catch (Exception e)

            {

                throw new ArgumentException(e.Message);

            }

        }

        /// <summary>

        /// private key ，java->.net

        /// </summary>

        /// <param name="privateKey"></param>

        /// <returns></returns>

        public static string RsaPrivateKeyJava2DotNet(string privateKey)

        {

            if (string.IsNullOrEmpty(privateKey))

            {

                return string.Empty;

            }

            var privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));

            return

                $"<RSAKeyValue><Modulus>{Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned())}</Modulus><Exponent>{Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned())}</Exponent><P>{Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned())}</P><Q>{Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned())}</Q><DP>{Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned())}</DP><DQ>{Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned())}</DQ><InverseQ>{Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned())}</InverseQ><D>{Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned())}</D></RSAKeyValue>";

        }

        /// <summary>

        /// public key ，java->.net

        /// </summary>

        /// <param name="publicKey"></param>

        /// <returns>格式转换结果</returns>

        public static string RsaPublicKeyJava2DotNet(string publicKey)

        {

            if (string.IsNullOrEmpty(publicKey))

            {

                return string.Empty;

            }

            var publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));

            return string.Format(

                "<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",

                Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),

                Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned())

            );

        }

        /// <summary>

        /// private key ，.net->java

        /// </summary>

        /// <param name="privateKey">.net生成的私钥</param>

        /// <returns></returns>

        public static string RsaPrivateKeyDotNet2Java(string privateKey)

        {

            var doc = new XmlDocument();

            doc.LoadXml(privateKey);

            var m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));

            var exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));

            var d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));

            var p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));

            var q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));

            var dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));

            var dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));

            var qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));

            var privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);

            var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);

            var serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();

            return Convert.ToBase64String(serializedPrivateBytes);

        }

        /// <summary>

        /// public key ，.net->java

        /// </summary>

        /// <param name="publicKey">.net生成的公钥</param>

        /// <returns></returns>

        public static string RsaPublicKeyDotNet2Java(string publicKey)

        {

            var doc = new XmlDocument();

            doc.LoadXml(publicKey);

            var m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));

            var p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));

            var pub = new RsaKeyParameters(false, m, p);

            var publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub);

            var serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();

            return Convert.ToBase64String(serializedPublicBytes);

        }

        // 处理 下面两种方式都会出现的 Operation is not supported on this platform 异常

        // RSA.Create().FromXmlString(privateKey)

        // new RSACryptoServiceProvider().FromXmlString(privateKey)

        /// <summary>

        /// 扩展FromXmlString

        /// </summary>

        /// <param name="rsa"></param>

        /// <param name="xmlString"></param>

        private static void FromXmlStringExtensions(this RSA rsa, string xmlString)

        {

            var parameters = new RSAParameters();

            var xmlDoc = new XmlDocument();

            xmlDoc.LoadXml(xmlString);

            if (xmlDoc.DocumentElement.Name.Equals("RSAKeyValue"))

            {

                foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)

                {

                    switch (node.Name)

                    {

                        case "Modulus":

                            parameters.Modulus = (string.IsNullOrEmpty(node.InnerText)

                                ? null

                                : Convert.FromBase64String(node.InnerText));

                            break;

                        case "Exponent":

                            parameters.Exponent = (string.IsNullOrEmpty(node.InnerText)

                                ? null

                                : Convert.FromBase64String(node.InnerText));

                            break;

                        case "P":

                            parameters.P = (string.IsNullOrEmpty(node.InnerText)

                                ? null

                                : Convert.FromBase64String(node.InnerText));

                            break;

                        case "Q":

                            parameters.Q = (string.IsNullOrEmpty(node.InnerText)

                                ? null

                                : Convert.FromBase64String(node.InnerText));

                            break;

                        case "DP":

                            parameters.DP = (string.IsNullOrEmpty(node.InnerText)

                                ? null

                                : Convert.FromBase64String(node.InnerText));

                            break;

                        case "DQ":

                            parameters.DQ = (string.IsNullOrEmpty(node.InnerText)

                                ? null

                                : Convert.FromBase64String(node.InnerText));

                            break;

                        case "InverseQ":

                            parameters.InverseQ = (string.IsNullOrEmpty(node.InnerText)

                                ? null

                                : Convert.FromBase64String(node.InnerText));

                            break;

                        case "D":

                            parameters.D = (string.IsNullOrEmpty(node.InnerText)

                                ? null

                                : Convert.FromBase64String(node.InnerText));

                            break;

                    }

                }

            }

            else

            {

                throw new Exception("Invalid XML RSA key.");

            }

            rsa.ImportParameters(parameters);

        }

        //        /// <summary>

        //        /// 扩展ToXmlString,创建公私钥

        //        /// </summary>

        //        /// <param name="includePrivateParameters"></param>

        //        /// <returns></returns>

        //        public static string ToCreateKey(bool includePrivateParameters)

        //        {

        //            using (var rsa = RSA.Create())

        //            {

        //                var parameters = rsa.ExportParameters(includePrivateParameters);

        //                return

        //                    $"<RSAKeyValue><Modulus>{(parameters.Modulus != null ? Convert.ToBase64String(parameters.Modulus) : null)}</Modulus><Exponent>{(parameters.Exponent != null ? Convert.ToBase64String(parameters.Exponent) : null)}</Exponent><P>{(parameters.P != null ? Convert.ToBase64String(parameters.P) : null)}</P><Q>{(parameters.Q != null ? Convert.ToBase64String(parameters.Q) : null)}</Q><DP>{(parameters.DP != null ? Convert.ToBase64String(parameters.DP) : null)}</DP><DQ>{(parameters.DQ != null ? Convert.ToBase64String(parameters.DQ) : null)}</DQ><InverseQ>{(parameters.InverseQ != null ? Convert.ToBase64String(parameters.InverseQ) : null)}</InverseQ><D>{(parameters.D != null ? Convert.ToBase64String(parameters.D) : null)}</D></RSAKeyValue>";

        //            }

        //        }

        /// <summary>

        /// Generate XML Format RSA Key. Result: Index 0 is the private key and index 1 is the public key

        /// </summary>

        /// <param name="keySize">Key Size.Unit: bits</param>

        /// <returns></returns>

        public static List<string> XmlKey(int keySize)

        {

            using (var rsa = RSA.Create())

            {

                rsa.KeySize = keySize;

                var rsap = rsa.ExportParameters(true);

                var res = new List<string>();

                var privatElement = new XElement("RSAKeyValue");

                //Modulus

                var primodulus = new XElement("Modulus", Convert.ToBase64String(rsap.Modulus));

                //Exponent

                var priexponent = new XElement("Exponent", Convert.ToBase64String(rsap.Exponent));

                //P

                var prip = new XElement("P", Convert.ToBase64String(rsap.P));

                //Q

                var priq = new XElement("Q", Convert.ToBase64String(rsap.Q));

                //DP

                var pridp = new XElement("DP", Convert.ToBase64String(rsap.DP));

                //DQ

                var pridq = new XElement("DQ", Convert.ToBase64String(rsap.DQ));

                //InverseQ

                var priinverseQ = new XElement("InverseQ", Convert.ToBase64String(rsap.InverseQ));

                //D

                var prid = new XElement("D", Convert.ToBase64String(rsap.D));

                privatElement.Add(primodulus);

                privatElement.Add(priexponent);

                privatElement.Add(prip);

                privatElement.Add(priq);

                privatElement.Add(pridp);

                privatElement.Add(pridq);

                privatElement.Add(priinverseQ);

                privatElement.Add(prid);

                //添加私钥

                res.Add(privatElement.ToString());

                var publicElement = new XElement("RSAKeyValue");

                //Modulus

                var pubmodulus = new XElement("Modulus", Convert.ToBase64String(rsap.Modulus));

                //Exponent

                var pubexponent = new XElement("Exponent", Convert.ToBase64String(rsap.Exponent));

                publicElement.Add(pubmodulus);

                publicElement.Add(pubexponent);

                //添加公钥

                res.Add(publicElement.ToString());

                return res;

            }

        }

        /// <summary>

        /// Generate RSA key in Pkcs1 format. Result: Index 0 is the private key and index 1 is the public key

        /// </summary>

        /// <param name="keySize">Key Size.Unit: bits</param>

        /// <param name="format">Whether the format is true If it is standard pem file format</param>

        /// <returns></returns>

        public static List<string> Pkcs1Key(int keySize, bool format = true)

        {

            var res = new List<string>();

            var kpGen = GeneratorUtilities.GetKeyPairGenerator("RSA");

            kpGen.Init(new KeyGenerationParameters(new SecureRandom(), keySize));

            var keyPair = kpGen.GenerateKeyPair();

            var sw = new StringWriter();

            var pWrt = new PemWriter(sw);

            pWrt.WriteObject(keyPair.Private);

            pWrt.Writer.Flush();

            var privateKey = sw.ToString();

            if (!format)

            {

                privateKey = privateKey.Replace("-----BEGIN RSA PRIVATE KEY-----", "").Replace("-----END RSA PRIVATE KEY-----", "").Replace("\r\n", "");

            }

            res.Add(privateKey);

            var swpub = new StringWriter();

            var pWrtpub = new PemWriter(swpub);

            pWrtpub.WriteObject(keyPair.Public);

            pWrtpub.Writer.Flush();

            var publicKey = swpub.ToString();

            if (!format)

            {

                publicKey = publicKey.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "").Replace("\r\n", "");

            }

            res.Add(publicKey);

            return res;

        }

        /// <summary>

        /// Generate Pkcs8 format RSA key. Result: Index 0 is the private key and index 1 is the public key

        /// </summary>

        /// <param name="keySize">Key Size.Unit: bits</param>

        /// <param name="format">Whether the format is true If it is standard pem file format</param>

        /// <returns></returns>

        public static List<string> Pkcs8Key(int keySize, bool format = true)

        {

            var res = new List<string>();

            var kpGen = GeneratorUtilities.GetKeyPairGenerator("RSA");

            kpGen.Init(new KeyGenerationParameters(new SecureRandom(), keySize));

            var keyPair = kpGen.GenerateKeyPair();

            var swpri = new StringWriter();

            var pWrtpri = new PemWriter(swpri);

            var pkcs8 = new Pkcs8Generator(keyPair.Private);

            pWrtpri.WriteObject(pkcs8);

            pWrtpri.Writer.Flush();

            var privateKey = swpri.ToString();

            if (!format)

            {

                privateKey = privateKey.Replace("-----BEGIN PRIVATE KEY-----", "").Replace("-----END PRIVATE KEY-----", "").Replace("\r\n", "");

            }

            res.Add(privateKey);

            var swpub = new StringWriter();

            var pWrtpub = new PemWriter(swpub);

            pWrtpub.WriteObject(keyPair.Public);

            pWrtpub.Writer.Flush();

            var publicKey = swpub.ToString();

            if (!format)

            {

                publicKey = publicKey.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "").Replace("\r\n", "");

            }

            res.Add(publicKey);

            return res;

        }

        /// <summary>

        /// Public Key Convert xml->xml

        /// </summary>

        /// <param name="publicKey"></param>

        /// <returns></returns>

        public static string PublicKeyXmlToPem(string publicKey)

        {

            var root = XElement.Parse(publicKey);

            //Modulus

            var modulus = root.Element("Modulus");

            //Exponent

            var exponent = root.Element("Exponent");

            var rsaKeyParameters = new RsaKeyParameters(false, new BigInteger(1, Convert.FromBase64String(modulus?.Value)), new BigInteger(1, Convert.FromBase64String(exponent?.Value)));

            var sw = new StringWriter();

            var pWrt = new PemWriter(sw);

            pWrt.WriteObject(rsaKeyParameters);

            pWrt.Writer.Flush();

            return sw.ToString();

        }

        /// <summary>

        /// Private Key Convert xml->Pkcs1

        /// </summary>

        /// <param name="privateKey"></param>

        /// <returns></returns>

        public static string PrivateKeyXmlToPkcs1(string privateKey)

        {

            var root = XElement.Parse(privateKey);

            //Modulus

            var modulus = root.Element("Modulus");

            //Exponent

            var exponent = root.Element("Exponent");

            //P

            var p = root.Element("P");

            //Q

            var q = root.Element("Q");

            //DP

            var dp = root.Element("DP");

            //DQ

            var dq = root.Element("DQ");

            //InverseQ

            var inverseQ = root.Element("InverseQ");

            //D

            var d = root.Element("D");

            var rsaPrivateCrtKeyParameters = new RsaPrivateCrtKeyParameters(

                new BigInteger(1, Convert.FromBase64String(modulus?.Value)),

                new BigInteger(1, Convert.FromBase64String(exponent?.Value)),

                new BigInteger(1, Convert.FromBase64String(d?.Value)),

                new BigInteger(1, Convert.FromBase64String(p?.Value)),

                new BigInteger(1, Convert.FromBase64String(q?.Value)),

                new BigInteger(1, Convert.FromBase64String(dp?.Value)),

                new BigInteger(1, Convert.FromBase64String(dq?.Value)),

                new BigInteger(1, Convert.FromBase64String(inverseQ?.Value)));

            var sw = new StringWriter();

            var pWrt = new PemWriter(sw);

            pWrt.WriteObject(rsaPrivateCrtKeyParameters);

            pWrt.Writer.Flush();

            return sw.ToString();

        }

        /// <summary>

        /// Format public key

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        private static string PublicKeyFormat(string str)

        {

            if (str.StartsWith("-----BEGIN PUBLIC KEY-----"))

            {

                return str;

            }

            var res = new List<string> { "-----BEGIN PUBLIC KEY-----" };

            var pos = 0;

            while (pos < str.Length)

            {

                var count = str.Length - pos < 64 ? str.Length - pos : 64;

                res.Add(str.Substring(pos, count));

                pos += count;

            }

            res.Add("-----END PUBLIC KEY-----");

            var resStr = string.Join("\r\n", res);

            return resStr;

        }

        /// <summary>

        /// Format Pkcs8 format private key

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        private static string Pkcs8PrivateKeyFormat(string str)

        {

            if (str.StartsWith("-----BEGIN PRIVATE KEY-----"))

            {

                return str;

            }

            var res = new List<string> { "-----BEGIN PRIVATE KEY-----" };

            var pos = 0;

            while (pos < str.Length)

            {

                var count = str.Length - pos < 64 ? str.Length - pos : 64;

                res.Add(str.Substring(pos, count));

                pos += count;

            }

            res.Add("-----END PRIVATE KEY-----");

            var resStr = string.Join("\r\n", res);

            return resStr;

        }

        /// <summary>

        /// Format Pkcs1 format private key

        /// Author:Zhiqiang Li

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        private static string Pkcs1PrivateKeyFormat(string str)

        {

            if (str.StartsWith("-----BEGIN RSA PRIVATE KEY-----"))

            {

                return str;

            }

            var res = new List<string> { "-----BEGIN RSA PRIVATE KEY-----" };

            var pos = 0;

            while (pos < str.Length)

            {

                var count = str.Length - pos < 64 ? str.Length - pos : 64;

                res.Add(str.Substring(pos, count));

                pos += count;

            }

            res.Add("-----END RSA PRIVATE KEY-----");

            var resStr = string.Join("\r\n", res);

            return resStr;

        }

        /// <summary>

        /// Remove the Pkcs8 format private key format

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        private static string Pkcs8PrivateKeyFormatRemove(string str)

        {

            if (!str.StartsWith("-----BEGIN PRIVATE KEY-----"))

            {

                return str;

            }

            return str.Replace("-----BEGIN PRIVATE KEY-----", "").Replace("-----END PRIVATE KEY-----", "")

                .Replace("\r\n", "");

        }

        /// <summary>

        /// public Key pem to xml

        /// </summary>

        /// <param name="publicKey"></param>

        /// <returns></returns>

        public static string PublicKeyPemToXml(string publicKey)

        {

            publicKey = PublicKeyFormat(publicKey);

            var pr = new PemReader(new StringReader(publicKey));

            var obj = pr.ReadObject();

            if (!(obj is RsaKeyParameters rsaKey))

            {

                throw new Exception("Public key format is incorrect");

            }

            var publicElement = new XElement("RSAKeyValue");

            //Modulus

            var pubmodulus = new XElement("Modulus", Convert.ToBase64String(rsaKey.Modulus.ToByteArrayUnsigned()));

            //Exponent

            var pubexponent = new XElement("Exponent", Convert.ToBase64String(rsaKey.Exponent.ToByteArrayUnsigned()));

            publicElement.Add(pubmodulus);

            publicElement.Add(pubexponent);

            return publicElement.ToString();

        }

        /// <summary>

        /// Private Key Convert Pkcs1->xml

        /// </summary>

        /// <param name="privateKey"></param>

        /// <returns></returns>

        public static string PrivateKeyPkcs1ToXml(string privateKey)

        {

            privateKey = Pkcs1PrivateKeyFormat(privateKey);

            var pr = new PemReader(new StringReader(privateKey));

            if (!(pr.ReadObject() is AsymmetricCipherKeyPair asymmetricCipherKeyPair))

            {

                throw new Exception("Private key format is incorrect");

            }

            var rsaPrivateCrtKeyParameters =

                (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(

                    PrivateKeyInfoFactory.CreatePrivateKeyInfo(asymmetricCipherKeyPair.Private));

            var privatElement = new XElement("RSAKeyValue");

            //Modulus

            var primodulus = new XElement("Modulus", Convert.ToBase64String(rsaPrivateCrtKeyParameters.Modulus.ToByteArrayUnsigned()));

            //Exponent

            var priexponent = new XElement("Exponent", Convert.ToBase64String(rsaPrivateCrtKeyParameters.PublicExponent.ToByteArrayUnsigned()));

            //P

            var prip = new XElement("P", Convert.ToBase64String(rsaPrivateCrtKeyParameters.P.ToByteArrayUnsigned()));

            //Q

            var priq = new XElement("Q", Convert.ToBase64String(rsaPrivateCrtKeyParameters.Q.ToByteArrayUnsigned()));

            //DP

            var pridp = new XElement("DP", Convert.ToBase64String(rsaPrivateCrtKeyParameters.DP.ToByteArrayUnsigned()));

            //DQ

            var pridq = new XElement("DQ", Convert.ToBase64String(rsaPrivateCrtKeyParameters.DQ.ToByteArrayUnsigned()));

            //InverseQ

            var priinverseQ = new XElement("InverseQ", Convert.ToBase64String(rsaPrivateCrtKeyParameters.QInv.ToByteArrayUnsigned()));

            //D

            var prid = new XElement("D", Convert.ToBase64String(rsaPrivateCrtKeyParameters.Exponent.ToByteArrayUnsigned()));

            privatElement.Add(primodulus);

            privatElement.Add(priexponent);

            privatElement.Add(prip);

            privatElement.Add(priq);

            privatElement.Add(pridp);

            privatElement.Add(pridq);

            privatElement.Add(priinverseQ);

            privatElement.Add(prid);

            return privatElement.ToString();

        }

        /// <summary>

        /// Private Key Convert Pkcs8->xml

        /// </summary>

        /// <param name="privateKey"></param>

        /// <returns></returns>

        public static string PrivateKeyPkcs8ToXml(string privateKey)

        {

            privateKey = Pkcs8PrivateKeyFormatRemove(privateKey);

            var privateKeyParam =

                (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));

            var privatElement = new XElement("RSAKeyValue");

            //Modulus

            var primodulus = new XElement("Modulus", Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()));

            //Exponent

            var priexponent = new XElement("Exponent", Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()));

            //P

            var prip = new XElement("P", Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()));

            //Q

            var priq = new XElement("Q", Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()));

            //DP

            var pridp = new XElement("DP", Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()));

            //DQ

            var pridq = new XElement("DQ", Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()));

            //InverseQ

            var priinverseQ = new XElement("InverseQ", Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()));

            //D

            var prid = new XElement("D", Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));

            privatElement.Add(primodulus);

            privatElement.Add(priexponent);

            privatElement.Add(prip);

            privatElement.Add(priq);

            privatElement.Add(pridp);

            privatElement.Add(pridq);

            privatElement.Add(priinverseQ);

            privatElement.Add(prid);

            return privatElement.ToString();

        }

        /// <summary>

        /// Private Key Convert xml->Pkcs8

        /// </summary>

        /// <param name="privateKey"></param>

        /// <returns></returns>

        public static string PrivateKeyXmlToPkcs8(string privateKey)

        {

            var root = XElement.Parse(privateKey);

            //Modulus

            var modulus = root.Element("Modulus");

            //Exponent

            var exponent = root.Element("Exponent");

            //P

            var p = root.Element("P");

            //Q

            var q = root.Element("Q");

            //DP

            var dp = root.Element("DP");

            //DQ

            var dq = root.Element("DQ");

            //InverseQ

            var inverseQ = root.Element("InverseQ");

            //D

            var d = root.Element("D");

            var rsaPrivateCrtKeyParameters = new RsaPrivateCrtKeyParameters(

                new BigInteger(1, Convert.FromBase64String(modulus?.Value)),

                new BigInteger(1, Convert.FromBase64String(exponent?.Value)),

                new BigInteger(1, Convert.FromBase64String(d?.Value)),

                new BigInteger(1, Convert.FromBase64String(p?.Value)),

                new BigInteger(1, Convert.FromBase64String(q?.Value)),

                new BigInteger(1, Convert.FromBase64String(dp?.Value)),

                new BigInteger(1, Convert.FromBase64String(dq?.Value)),

                new BigInteger(1, Convert.FromBase64String(inverseQ?.Value)));

            var swpri = new StringWriter();

            var pWrtpri = new PemWriter(swpri);

            var pkcs8 = new Pkcs8Generator(rsaPrivateCrtKeyParameters);

            pWrtpri.WriteObject(pkcs8);

            pWrtpri.Writer.Flush();

            return swpri.ToString();

        }

        /// <summary>

        /// Private Key Convert Pkcs1->Pkcs8

        /// </summary>

        /// <param name="privateKey"></param>

        /// <returns></returns>

        public static string PrivateKeyPkcs1ToPkcs8(string privateKey)

        {

            privateKey = Pkcs1PrivateKeyFormat(privateKey);

            var pr = new PemReader(new StringReader(privateKey));

            var kp = pr.ReadObject() as AsymmetricCipherKeyPair;

            var sw = new StringWriter();

            var pWrt = new PemWriter(sw);

            var pkcs8 = new Pkcs8Generator(kp?.Private);

            pWrt.WriteObject(pkcs8);

            pWrt.Writer.Flush();

            var result = sw.ToString();

            return result;

        }

        /// <summary>

        /// Private Key Convert Pkcs8->Pkcs1

        /// </summary>

        /// <param name="privateKey"></param>

        /// <returns></returns>

        public static string PrivateKeyPkcs8ToPkcs1(string privateKey)

        {

            privateKey = Pkcs8PrivateKeyFormat(privateKey);

            var pr = new PemReader(new StringReader(privateKey));

            var kp = pr.ReadObject() as RsaPrivateCrtKeyParameters;

            var keyParameter = PrivateKeyFactory.CreateKey(PrivateKeyInfoFactory.CreatePrivateKeyInfo(kp));

            var sw = new StringWriter();

            var pWrt = new PemWriter(sw);

            pWrt.WriteObject(keyParameter);

            pWrt.Writer.Flush();

            var result = sw.ToString();

            return result;

        }

    }

}

.net core 常用rsa 加签类的更多相关文章

java RSA 加签验签【转】
引用自: http://blog.csdn.net/wangqiuyun/article/details/42143957/ java RSA 加签验签 package com.testdemo.co ...
RSA加密解密及RSA加签验签
RSA安全性应用场景说明在刚接触RSA的时候,会混淆RSA加密解密和RSA加签验签的概念.简单来说加密解密是公钥加密私钥解密,持有公钥(多人持有)可以对数据加密,但是只有持有私钥(一人持有)才可以解 ...
微信支付 V3 RSA 加签踩坑
最近在做微信支付,根据微信官方文档上的要求用RSA加签去请求支付窗口的调起,下面详细列举支付开发过程: 当前项目的流程大概是,前端根据后端要求提交数据------->拿到后台返回的prepay ...
PHP RSA加签的实现过程
一.得到私钥文件mycert.key 2.从pfx提取密钥信息,并转换为key格式(pfx使用pkcs12模式补足) (1)提取密钥对 openssl pkcs12 -in 1.pfx -nocert ...
ruby中rsa加签解签方法
# coding:utf-8require 'openssl'require 'base64'# rsa签名,文本内容和私钥路径def rsa_sign(data,private_key_path) ...
ruby的加密方法整理（des rsa加密加签）
# coding:utf-8require 'openssl'require 'base64'#des加密并且base64编码def des_encrypt des_key, des_text des ...
RSA加密解密与加签验签
RSA公钥加密算法是1977年由罗纳德·李维斯特(Ron Rivest).阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的.1987年7月首次在美国公布 ...
RSA加解密&RSA加验签详解
RSA 加密算法是目前最有影响力的公钥加密算法,并且被普遍认为是目前最优秀的公钥方案之一.RSA 是第一个能同时用于加密和数字签名的算法,它能够抵抗到目前为止已知的所有密码攻击,已 ...
RSA体系 c++/java相互进行加签验签--转
在web开发中,采用RSA公钥密钥体系自制ukey,文件证书登陆时,普遍的做法为:在浏览器端采用c++ activex控件,使用 c++的第三库openssl进行RAS加签操作,在服务器端采用java ...

随机推荐

[Java] javaEE
定义面向企业级应用中一些通用模块制定的标准避免重复开发,解决代码可靠性问题 13种规范 JDBC(JavaDatabase Connectivity):数据库连接以统一方式访问数据库的API J ...
【转载】有图 KVM折腾记..
KVM折腾记...https://lengjibo.github.io/KVM%E6%8A%98%E8%85%BE%E8%AE%B0/ Veröffentlicht am 2018-09-20 | ...
linux 视频输出xrandr设置命令
linux 视频输出xrandr设置命令沈祥佑关注 0.592019.03.28 17:44:09字数 397阅读 6,886 xrandr 不带参数的xrandr 命令会列出系统支持的视频接口名称 ...
CentOS 7系统中的时间日期设置
修改 CentOS 7系统中的时间日期设置 timedatectl set-ntp no timedatectl timedatectl set-time 2022-06-04 timedatectl ...
Centos7 安装 htop
此安装方法是目前位置我了解到的最简介.最快速的安装方法.本人亲验: 系统版本: CentOS Linux release 7.3.1611 (Core) 安装步骤: yum -y instal ...
用urllib库几行代码实现最简单爬虫
""" 使用urllib.request()请求一个网页内容,并且把内容打印出来. """ from urllib import reque ...
MyBaits 全局配置文件(mybatis-config.xml)
什么是 MyBatis 全局配置文件 MyBatis 全局配置文件包含影响 MyBatis 框架正常使用的功能设置和属性信息. 它的作用好比手机里的设置图标,点击这个图标就可以帮助我们查看手机的属性信 ...
3.20 tr：替换或删除字符
tr命令从标准输入中替换.缩减或删除字符,并将结果写到标准输出. tr [option] [SET1] [SET2] tr [选项] [字符1] [字符2] -d 删除字符 -s ...
STM32 中的HARDFAULT 的查找方法
http://blog.csdn.net/zyboy2000/article/details/7668331
[leetcode] 72. 编辑距离(二维动态规划)
72. 编辑距离再次验证leetcode的评判机有问题啊!同样的代码,第一次提交超时,第二次提交就通过了! 此题用动态规划解决. 这题一开始还真难到我了,琢磨半天没有思路.于是乎去了网上喵了下题解看 ...

.net core 常用rsa 加签类

.net core 常用rsa 加签类的更多相关文章

随机推荐

热门专题