C#.NET RSA 私钥签名 公钥验证签名

时间：2024-09-14 09:07:32

C#.NET RSA 私钥签名 公钥验证签名 公钥验签

1.待签名字符串转为byte数组时，一般使用UTF8。

2.将私钥字符串（PKCS8或PKCS1格式）转为C#.NET的RSACryptoServiceProvider对象。

3.使用RSACryptoServiceProvider对象的SignData方法算出签名值，结果为byte数组。

4.签名值是byte数组，不便于传输，一般是转为BASE64字符串来传输。

5.RSACryptoServiceProvider对象+SHA256算法，对标JAVA的SHA256withRSA。

6.openssl生成的私钥默认是PKCS1的，示例中是转成了PKCS8格式，在解决方案的“公私钥”文件夹，用记事本打开，填入程序即可。

私钥签名：

private void btnSign_Click(object sender, EventArgs e)

        {

            try

            {

                if (string.IsNullOrWhiteSpace(txtPrivateKey.Text) || string.IsNullOrWhiteSpace(txtToSignStr.Text))

                {

                    MessageBox.Show("私钥和字符串不能为空");

                    return;

                }

                //SHA256withRSA

                string fnstr = txtToSignStr.Text;//待签名字符串

                //1。转换私钥字符串为RSACryptoServiceProvider对象

                RSACryptoServiceProvider rsaP = RsaUtil.LoadPrivateKey(txtPrivateKey.Text, "PKCS8");

                byte[] data = Encoding.UTF8.GetBytes(fnstr);//待签名字符串转成byte数组，UTF8

                byte[] byteSign = rsaP.SignData(data, "SHA256");//对应JAVA的RSAwithSHA256

                string sign = Convert.ToBase64String(byteSign);//签名byte数组转为BASE64字符串

                txtSign.Text = sign;

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.Message);

            }

        }

公钥验证签名：

private void button1_Click(object sender, EventArgs e)

        {

            try

            {

                if (string.IsNullOrWhiteSpace(txtPubKey.Text) || string.IsNullOrWhiteSpace(txtToSignStr.Text) || string.IsNullOrWhiteSpace(txtSign.Text))

                {

                    MessageBox.Show("公钥，签名字符串，签名 不能为空");

                    return;

                }

                byte[] signature = Convert.FromBase64String(txtSign.Text);//签名值转为byte数组

                //SHA256withRSA

                string fnstr = txtToSignStr.Text;

                //1。转换私钥字符串为RSACryptoServiceProvider对象

                RSACryptoServiceProvider rsaP = RsaUtil.LoadPublicKey(txtPubKey.Text );

                byte[] data = Encoding.UTF8.GetBytes(fnstr);//待签名字符串转成byte数组，UTF8

                bool validSign = rsaP.VerifyData(data, "SHA256", signature);//对应JAVA的RSAwithSHA256

                if(validSign)

                    lblValidRst.Text = "验证签名通过："+DateTime.Now.ToString();

                else

                    lblValidRst.Text = "验证签名 不通过：" + DateTime.Now.ToString();

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.Message);

            }

        }

工具类：

using Org.BouncyCastle.Crypto.Parameters;

using Org.BouncyCastle.Security;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Security.Cryptography;

using System.Security.Cryptography.X509Certificates;

using System.Text;

using System.Threading.Tasks;

namespace CommonUtils

{

    public static class RsaUtil

    {

        #region 加载私钥

        /// <summary>

        /// 转换私钥字符串为RSACryptoServiceProvider

        /// </summary>

        /// <param name="privateKeyStr">私钥字符串</param>

        /// <param name="keyFormat">PKCS8,PKCS1</param>

        /// <param name="signType">RSA 私钥长度1024 ,RSA2 私钥长度2048</param>

        /// <returns></returns>

        public static RSACryptoServiceProvider LoadPrivateKey(string privateKeyStr, string keyFormat)

        {

            string signType = "RSA";

            if (privateKeyStr.Length > 1024)

            {

                signType = "RSA2";

            }

            //PKCS8,PKCS1

            if (keyFormat == "PKCS1")

            {

                return LoadPrivateKeyPKCS1(privateKeyStr, signType);

            }

            else

            {

                return LoadPrivateKeyPKCS8(privateKeyStr);

            }

        }

        /// <summary>

        /// PKCS1 格式私钥转 RSACryptoServiceProvider 对象

        /// </summary>

        /// <param name="strKey">pcsk1 私钥的文本内容</param>

        /// <param name="signType">RSA 私钥长度1024 ,RSA2 私钥长度2048 </param>

        /// <returns></returns>

        public static RSACryptoServiceProvider LoadPrivateKeyPKCS1(string privateKeyPemPkcs1, string signType)

        {

            try

            {

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

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

                byte[] data = null;

                //读取带

                data = Convert.FromBase64String(privateKeyPemPkcs1);

                RSACryptoServiceProvider rsa = DecodeRSAPrivateKey(data, signType);

                return rsa;

            }

            catch (Exception ex)

            {

                throw ex;

            }

            return null;

        }

        private static RSACryptoServiceProvider DecodeRSAPrivateKey(byte[] privkey, string signType)

        {

            byte[] MODULUS, E, D, P, Q, DP, DQ, IQ;

            // --------- Set up stream to decode the asn.1 encoded RSA private key ------

            MemoryStream mem = new MemoryStream(privkey);

            BinaryReader binr = new BinaryReader(mem);  //wrap Memory Stream with BinaryReader for easy reading

            byte bt = 0;

            ushort twobytes = 0;

            int elems = 0;

            try

            {

                twobytes = binr.ReadUInt16();

                if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)

                    binr.ReadByte();    //advance 1 byte

                else if (twobytes == 0x8230)

                    binr.ReadInt16();    //advance 2 bytes

                else

                    return null;

                twobytes = binr.ReadUInt16();

                if (twobytes != 0x0102) //version number

                    return null;

                bt = binr.ReadByte();

                if (bt != 0x00)

                    return null;

                //------ all private key components are Integer sequences ----

                elems = GetIntegerSize(binr);

                MODULUS = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);

                E = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);

                D = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);

                P = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);

                Q = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);

                DP = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);

                DQ = binr.ReadBytes(elems);

                elems = GetIntegerSize(binr);

                IQ = binr.ReadBytes(elems);

                // ------- create RSACryptoServiceProvider instance and initialize with public key -----

                CspParameters CspParameters = new CspParameters();

                CspParameters.Flags = CspProviderFlags.UseMachineKeyStore;

                int bitLen = 1024;

                if ("RSA2".Equals(signType))

                {

                    bitLen = 2048;

                }

                RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(bitLen, CspParameters);

                //RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();

                RSAParameters RSAparams = new RSAParameters();

                RSAparams.Modulus = MODULUS;

                RSAparams.Exponent = E;

                RSAparams.D = D;

                RSAparams.P = P;

                RSAparams.Q = Q;

                RSAparams.DP = DP;

                RSAparams.DQ = DQ;

                RSAparams.InverseQ = IQ;

                RSA.ImportParameters(RSAparams);

                return RSA;

            }

            catch (Exception ex)

            {

                throw ex;

                // return null;

            }

            finally

            {

                binr.Close();

            }

        }

        private static int GetIntegerSize(BinaryReader binr)

        {

            byte bt = 0;

            byte lowbyte = 0x00;

            byte highbyte = 0x00;

            int count = 0;

            bt = binr.ReadByte();

            if (bt != 0x02)        //expect integer

                return 0;

            bt = binr.ReadByte();

            if (bt == 0x81)

                count = binr.ReadByte();    // data size in next byte

            else

                if (bt == 0x82)

            {

                highbyte = binr.ReadByte(); // data size in next 2 bytes

                lowbyte = binr.ReadByte();

                byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };

                count = BitConverter.ToInt32(modint, 0);

            }

            else

            {

                count = bt;     // we already have the data size

            }

            while (binr.ReadByte() == 0x00)

            {    //remove high order zeros in data

                count -= 1;

            }

            binr.BaseStream.Seek(-1, SeekOrigin.Current);        //last ReadByte wasn't a removed zero, so back up a byte

            return count;

        }

        /// <summary>

        /// PKCS8 文本转RSACryptoServiceProvider 对象

        /// </summary>

        /// <param name="privateKeyPemPkcs8"></param>

        /// <returns></returns>

        public static RSACryptoServiceProvider LoadPrivateKeyPKCS8(string privateKeyPemPkcs8)

        {

            try

            {

                //PKCS8是“BEGIN PRIVATE KEY”

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

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

                //pkcs8 文本先转为 .NET XML 私钥字符串

                string privateKeyXml = RSAPrivateKeyJava2DotNet(privateKeyPemPkcs8);

                RSACryptoServiceProvider publicRsa = new RSACryptoServiceProvider();

                publicRsa.FromXmlString(privateKeyXml);

                return publicRsa;

            }

            catch (Exception ex)

            {

                throw ex;

            }

        }

        /// <summary>

        /// PKCS8 私钥文本 转 .NET XML 私钥文本

        /// </summary>

        /// <param name="privateKeyPemPkcs8"></param>

        /// <returns></returns>

        public static string RSAPrivateKeyJava2DotNet(string privateKeyPemPkcs8)

        {

            RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKeyPemPkcs8));

            return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent><P>{2}</P><Q>{3}</Q><DP>{4}</DP><DQ>{5}</DQ><InverseQ>{6}</InverseQ><D>{7}</D></RSAKeyValue>",

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

            Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()),

            Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()),

            Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()),

            Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()),

            Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()),

            Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()),

            Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));

        }

        #endregion

        /// <summary>

        /// 加载公钥证书

        /// </summary>

        /// <param name="publicKeyCert">公钥证书文本内容</param>

        /// <returns></returns>

        public static RSACryptoServiceProvider LoadPublicCert(string publicKeyCert)

        {

            publicKeyCert = publicKeyCert.Replace("-----BEGIN CERTIFICATE-----", "").Replace("-----END CERTIFICATE-----", "").Replace("\r", "").Replace("\n", "").Trim();

            byte[] bytesCerContent = Convert.FromBase64String(publicKeyCert);

            X509Certificate2 x509 = new X509Certificate2(bytesCerContent);

            RSACryptoServiceProvider rsaPub = (RSACryptoServiceProvider)x509.PublicKey.Key;

            return rsaPub;

        }

        /// <summary>

        /// pem 公钥文本 转  .NET RSACryptoServiceProvider。

        /// </summary>

        /// <param name="publicKeyPem"></param>

        /// <returns></returns>

        public static RSACryptoServiceProvider LoadPublicKey(string publicKeyPem)

        {

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

            //pem 公钥文本 转  .NET XML 公钥文本。

            string publicKeyXml = RSAPublicKeyJava2DotNet(publicKeyPem);

            RSACryptoServiceProvider publicRsa = new RSACryptoServiceProvider();

            publicRsa.FromXmlString(publicKeyXml);

            return publicRsa;

        }

        /// <summary>

        /// pem 公钥文本 转  .NET XML 公钥文本。

        /// </summary>

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

        /// <returns></returns>

        private static string RSAPublicKeyJava2DotNet(string publicKey)

        {

            RsaKeyParameters 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()));

        }

    }

}

-源码：https://gitee.com/runliuv/mypub/tree/master/donetproj

相关文章