1.添加AES和RSA默认实现

2.添加AES和RSA在不同环境下测试

src/GBNewEnergy.Protocol.Test/NEPackageTest.cs

@@ -14,7 +14,7 @@ namespace GBNewEnergy.Protocol.Test
     {
         private readonly NEGlobalConfigs NEGlobalConfigs = new NEGlobalConfigs()
         {
-             NEEncryptKey="smallchi" 
+
         };
         #region 车辆登入
         [Fact]

src/GBNewEnergy.Protocol/NEEncrypts/NEAES128EncryptImpl.cs → src/GBNewEnergy.Protocol/NEEncrypts/Default_NEAES128EncryptImpl.cs

@@ -1,30 +1,31 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
+using System.IO;
 using System.Security.Cryptography;
-using System.Text;
 
 namespace GBNewEnergy.Protocol.NEEncrypts
 {
-    public class NEAES128EncryptImpl : INEEncrypt
+    public class Default_NEAES128EncryptImpl : NEAESBase
     {
-        private readonly NEGlobalConfigs _nEConfigs;
+        public override string PrivateKey { get; }
 
-        /// <summary>
-        /// 盐字节必须为至少8个字节
-        /// </summary>
-        private readonly static byte[] saltBytes = new byte[9] { 13, 34, 27, 67, 189, 255, 104, 219, 122 };
+        public override byte[] SaltBytes { get; }
 
-        public NEAES128EncryptImpl(NEGlobalConfigs nEConfigs)
+        public Default_NEAES128EncryptImpl(string privateKey)
         {
-            _nEConfigs = nEConfigs;
+            PrivateKey = privateKey;
+            SaltBytes = new byte[9] { 13, 34, 27, 67, 189, 255, 104, 219, 122 };
         }
 
-        public byte[] Encrypt(byte[] buffer)
+        public Default_NEAES128EncryptImpl(string privateKey, byte[] saltBytes)
+        {
+            PrivateKey = privateKey;
+            SaltBytes = saltBytes;
+        }
+
+        public override byte[] Encrypt(byte[] buffer)
         {
             using (Aes encryptor = Aes.Create())
             {
-                Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(_nEConfigs.NEEncryptKey, saltBytes);
+                Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(PrivateKey, SaltBytes);
                 encryptor.Key = pdb.GetBytes(32);
                 encryptor.IV = pdb.GetBytes(16);
                 using (MemoryStream ms = new MemoryStream())
@@ -37,11 +38,11 @@ namespace GBNewEnergy.Protocol.NEEncrypts
             }
         }
 
-        public byte[] Decrypt(byte[] buffer)
+        public override byte[] Decrypt(byte[] buffer)
         {
             using (Aes encryptor = Aes.Create())
             {
-                Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(_nEConfigs.NEEncryptKey, saltBytes);
+                Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(PrivateKey, SaltBytes);
                 encryptor.Key = pdb.GetBytes(32);
                 encryptor.IV = pdb.GetBytes(16);
                 using (MemoryStream ms = new MemoryStream())

src/GBNewEnergy.Protocol/NEEncrypts/Default_NERSAEncryptImpl.cs

@@ -0,0 +1,193 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+using System.Xml;
+
+namespace GBNewEnergy.Protocol.NEEncrypts
+{
+#if NETSTANDARD2_0
+    public class Default_NERSAEncryptImpl : NERSABase
+    {
+        private readonly RSA _privateKeyRsaProvider;
+        private readonly RSA _publicKeyRsaProvider;
+        private readonly Encoding _encoding;
+
+        public override string HashAlgorithmStr=>throw new NotImplementedException();
+
+        public override string PublicKey { get; }
+
+        public override string PrivateKey { get; }
+
+        public override HashAlgorithmName HashAlgorithmName { get; }
+
+        public Default_NERSAEncryptImpl(Encoding encoding, HashAlgorithmName hashAlgorithmName, string publicKey, string privateKey)
+        {
+            _privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey); 
+            _publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey); 
+            HashAlgorithmName = hashAlgorithmName;
+            _encoding = encoding;
+            PublicKey = publicKey;
+            PrivateKey = privateKey;
+        }
+
+        public override byte[] Decrypt(byte[] buffer)
+        {
+             return _privateKeyRsaProvider.Decrypt(buffer, RSAEncryptionPadding.Pkcs1);
+        }
+
+        public override byte[] Encrypt(byte[] buffer)
+        {
+             return _publicKeyRsaProvider.Encrypt(buffer, RSAEncryptionPadding.Pkcs1);
+        }
+
+        /// <summary>
+        /// 使用私钥签名
+        /// </summary>
+        /// <param name="data">原始数据</param>
+        /// <returns></returns>
+        public override string Sign(string data)
+        {
+            byte[] dataBytes = _encoding.GetBytes(data);
+            var signatureBytes = _privateKeyRsaProvider.SignData(dataBytes, HashAlgorithmName, RSASignaturePadding.Pkcs1);
+            return Convert.ToBase64String(signatureBytes);
+        }
+
+        /// <summary>
+        /// 使用公钥验证签名
+        /// </summary>
+        /// <param name="data">原始数据</param>
+        /// <param name="sign">签名</param>
+        /// <returns></returns>
+        public override bool Verify(string data, string sign)
+        {
+            byte[] dataBytes = _encoding.GetBytes(data);
+            byte[] signBytes = Convert.FromBase64String(sign);
+            var verify = _publicKeyRsaProvider.VerifyData(dataBytes, signBytes, HashAlgorithmName, RSASignaturePadding.Pkcs1);
+            return verify;
+        }
+
+        private RSA CreateRsaProviderFromPublicKey(string publicKeyString)
+        {
+            var rsa = RSA.Create();
+            FromXmlStringExtensions(rsa,publicKeyString);
+            return rsa;
+        }
+
+        private RSA CreateRsaProviderFromPrivateKey(string privateKey)
+        {
+            var rsa = RSA.Create();
+            FromXmlStringExtensions(rsa, privateKey);
+            return rsa;
+        }
+
+        private int GetIntegerSize(BinaryReader binr)
+        {
+            byte bt = 0;
+            int count = 0;
+            bt = binr.ReadByte();
+            if (bt != 0x02)
+                return 0;
+            bt = binr.ReadByte();
+
+            if (bt == 0x81)
+                count = binr.ReadByte();
+            else
+            if (bt == 0x82)
+            {
+                var highbyte = binr.ReadByte();
+                var lowbyte = binr.ReadByte();
+                byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };
+                count = BitConverter.ToInt32(modint, 0);
+            }
+            else
+            {
+                count = bt;
+            }
+
+            while (binr.ReadByte() == 0x00)
+            {
+                count -= 1;
+            }
+            binr.BaseStream.Seek(-1, SeekOrigin.Current);
+            return count;
+        }
+
+        private bool CompareBytearrays(byte[] a, byte[] b)
+        {
+            if (a.Length != b.Length)
+                return false;
+            int i = 0;
+            foreach (byte c in a)
+            {
+                if (c != b[i])
+                    return false;
+                i++;
+            }
+            return true;
+        }
+
+        private static void FromXmlStringExtensions(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);
+        }
+    }
+#endif
+}

src/GBNewEnergy.Protocol/NEEncrypts/Default_NERSAEncryptImpl_NET.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace GBNewEnergy.Protocol.NEEncrypts
+{
+    public class Default_NERSAEncryptImpl_NET : NERSABase
+    {
+        private readonly Encoding _encoding;
+
+        public Default_NERSAEncryptImpl_NET(Encoding encoding,string hashAlgorithmStr, string publicKey, string privateKey)
+        {
+            _encoding = encoding;
+            HashAlgorithmStr = hashAlgorithmStr;
+            PublicKey = publicKey;
+            PrivateKey = privateKey;
+        }
+
+#if NETSTANDARD2_0
+        public override HashAlgorithmName HashAlgorithmName => throw new NotImplementedException();
+#endif
+        public override string HashAlgorithmStr { get;}
+
+        public override string PublicKey { get;  }
+
+        public override string PrivateKey { get;}
+
+        public override byte[] Decrypt(byte[] buffer)
+        {
+            using (RSACryptoServiceProvider provider=new RSACryptoServiceProvider())
+            {
+                provider.FromXmlString(PrivateKey);
+                return provider.Decrypt(buffer, false);
+            }
+        }
+
+        public override byte[] Encrypt(byte[] buffer)
+        {
+            using (RSACryptoServiceProvider provider = new RSACryptoServiceProvider())
+            {
+                provider.FromXmlString(PublicKey);
+                return provider.Encrypt(buffer, false);
+            }
+        }
+
+        /// <summary>
+        /// 使用私钥签名
+        /// </summary>
+        /// <param name="data">原始数据</param>
+        /// <returns></returns>
+        public override string Sign(string data)
+        {
+            byte[] dataBytes = _encoding.GetBytes(data);
+            byte[] rgbHash = HashAlgorithm.Create(HashAlgorithmStr).ComputeHash(dataBytes);
+            using (RSACryptoServiceProvider key = new RSACryptoServiceProvider())
+            {
+                key.FromXmlString(PrivateKey);
+                RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
+                formatter.SetHashAlgorithm(HashAlgorithmStr);
+                byte[] inArray = formatter.CreateSignature(rgbHash);
+                return Convert.ToBase64String(inArray);
+            }
+        }
+
+        /// <summary>
+        /// 使用公钥验证签名
+        /// </summary>
+        /// <param name="data">原始数据</param>
+        /// <param name="sign">签名</param>
+        /// <returns></returns>
+        public override bool Verify(string data, string sign)
+        {
+            byte[] dataBytes = _encoding.GetBytes(data);
+            byte[] signBytes = Convert.FromBase64String(sign);
+            byte[] rgbHash = HashAlgorithm.Create(HashAlgorithmStr).ComputeHash(dataBytes);
+            using (RSACryptoServiceProvider key = new RSACryptoServiceProvider())
+            {
+                key.FromXmlString(PublicKey);
+                RSAPKCS1SignatureDeformatter deformatter = new RSAPKCS1SignatureDeformatter(key);
+                deformatter.SetHashAlgorithm(HashAlgorithmStr);
+                byte[] rgbSignature = Convert.FromBase64String(sign);
+                if (deformatter.VerifySignature(rgbHash, rgbSignature))
+                {
+                    return true;
+                }
+                return false;
+            }
+        }
+    }
+}

src/GBNewEnergy.Protocol/NEEncrypts/NEAESBase.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GBNewEnergy.Protocol.NEEncrypts
+{
+    public abstract class NEAESBase : INEEncrypt
+    {
+        public abstract string PrivateKey { get; }
+        public abstract byte[] SaltBytes { get; }
+        public abstract byte[] Decrypt(byte[] buffer);
+        public abstract byte[] Encrypt(byte[] buffer);
+    }
+}

src/GBNewEnergy.Protocol/NEEncrypts/NERSABase.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace GBNewEnergy.Protocol.NEEncrypts
+{
+    public abstract class NERSABase : INEEncrypt
+    {
+        public abstract byte[] Decrypt(byte[] buffer);
+        public abstract byte[] Encrypt(byte[] buffer);
+
+#if NETSTANDARD2_0
+        /// <summary>
+        /// dotnet core 使用
+        /// </summary>
+        public abstract HashAlgorithmName HashAlgorithmName { get; }
+#endif
+        /// <summary>
+        /// .net framework 使用
+        /// 哈希算法
+        /// MD5 new MD5CryptoServiceProvider()
+        /// SHA1 new SHA1CryptoServiceProvider()
+        /// SHA256 new SHA256CryptoServiceProvider()
+        /// SHA384 new SHA384CryptoServiceProvider()
+        /// SHA512 new SHA512CryptoServiceProvider()
+        /// </summary>
+        public abstract string HashAlgorithmStr { get; }
+        public abstract string PublicKey { get; }
+        public abstract string PrivateKey { get; }
+        /// <summary>
+        /// 使用私钥签名
+        /// </summary>
+        /// <param name="data">原始数据</param>
+        /// <returns></returns>
+        public abstract bool Verify(string data, string sign);
+        /// <summary>
+        /// 使用公钥验证签名
+        /// </summary>
+        /// <param name="data">原始数据</param>
+        /// <param name="sign">签名</param>
+        /// <returns></returns>
+        public abstract string Sign(string data);
+    }
+}

src/GBNewEnergy.Protocol/NEEncrypts/NERSAEncryptImpl.cs

@@ -1,27 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace GBNewEnergy.Protocol.NEEncrypts
-{
-#warning 待加解密
-    public class NERSAEncryptImpl : INEEncrypt
-    {
-        private readonly NEGlobalConfigs _nEConfigs;
-
-        public NERSAEncryptImpl(NEGlobalConfigs nEConfigs)
-        {
-            _nEConfigs = nEConfigs;
-        }
-
-        public byte[] Decrypt(byte[] buffer)
-        {
-            throw new NotImplementedException();
-        }
-
-        public byte[] Encrypt(byte[] buffer)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}

src/GBNewEnergy.Protocol/NEGlobalConfigs.cs

@@ -1,6 +1,4 @@
 using GBNewEnergy.Protocol.Enums;
-using System;
-using System.Collections.Generic;
 using System.Text;
 
 namespace GBNewEnergy.Protocol
@@ -8,9 +6,9 @@ namespace GBNewEnergy.Protocol
     public  class NEGlobalConfigs
     {
         /// <summary>
-        /// 密钥
+        /// 加密编码
         /// </summary>
-        public string NEEncryptKey { get; set; }
+        public Encoding NEEncryptEncoding { get; set; } = Encoding.UTF8;
         /// <summary>
         /// 数据单元加密方式
         /// 0x01：数据不加密；0x02：数据经过 RSA 算法加密；0x03:数据经过 AES128 位算法加密；“0xFE”表示异常，“0xFF”表示无效

src/NEEncrypts.Tests/NEEncryptsNET4.Test/Program.cs

@@ -13,17 +13,33 @@ namespace NEEncryptsNET4.Test
     {
         static void Main(string[] args)
         {
-            NEAES128EncryptImpl nE_AES128EncryptImpl = new NEAES128EncryptImpl(
-                new GBNewEnergy.Protocol.NEGlobalConfigs()
-                {
-                     NEEncryptKey="smallchi"
-                });
+            Default_NEAES128EncryptImpl nE_AES128EncryptImpl = new Default_NEAES128EncryptImpl("smallchi");
             string str = "aaasssddd123";
             var bytes = Encoding.UTF8.GetBytes(str);
-            var encrypt=nE_AES128EncryptImpl.Encrypt(bytes);
-            Console.WriteLine("原数据:"+ str);
-            Console.WriteLine("加密后:"+ encrypt.ToHexString());
+            var encrypt = nE_AES128EncryptImpl.Encrypt(bytes);
+            Console.WriteLine("原数据:" + str);
+            Console.WriteLine("加密后:" + encrypt.ToHexString());
             Console.WriteLine("解密后:" + Encoding.UTF8.GetString(nE_AES128EncryptImpl.Decrypt(encrypt)));
+
+            Default_NERSAEncryptImpl_NET rsa = new Default_NERSAEncryptImpl_NET(Encoding.UTF8, 
+                "SHA256",
+                "<RSAKeyValue><Modulus>s+rl5mtcckCF9mEECD86L9UE2pbCR4CuiqDepwpiZCEflymQLNC3qNUPDlua9/kltyu6L489uimHRbEp4C7Gl7dDmaXVZLUVGkgUCZoRc8MrOw4+BiVAeQtCDdilPpA7DMN0bMfJAj3U4GuTU89/OWZMb9SYFfqEHM2e60PZHIU=</Modulus><Exponent>AQAB</Exponent><P>8qSTX42w2NaMCXL0PTZuacUFdJj93KopOJPD2q/JfmXSjXHV/IQK9YlCVKXHucqy8xcQgjkaKHqy3Rse14SZ7Q==</P><Q>vdJfDZ6ZIAQDx0sQbmbadHb6EOr8/oXo8B1CUSG0LqFZgDY7vBj17ujd6UhJWzhsg/5/3L+m4wDjMkUpOExZ+Q==</Q><DP>Av3Uc1Ej5QiAIX2xVS/enJ85Of7I4neWmoP33jJcoZpPxj6pDLv0BqLylmiU1c2R9z1JjtF1aRpaKi+zaaTQ4Q==</DP><DQ>Pv5yhv2MCYDrlBbIJCtD8gSN5lFllj3wWMcM/Am4VwU6w368Aicybo+fHUzc80XdVUx/OE3t30WrIEKtdD56WQ==</DQ><InverseQ>OcUQg0/kEGi9l2CgXCLKmQ1/1VVb+r89LXTO6rqi2wg5txkJIIXXePx7ce0Bh0eEnZzeSudwBLA3kqXmeAyYaw==</InverseQ><D>mnPL+zwtd7OmjTUJ5h6JUCi56wFDNWjl7gJeQd4rSzQYT4eRyrc/A4QsUbIYXkqXsyCpzExWvGsMQqrtfRQKzR53MBL3MQln5BjAUql2NqCkM2KT/D8Px5M21/TpMAycK4tGLOHgcCQRH1PQLHG1OfpfDASIzLwLgMjvMuHnIyE=</D></RSAKeyValue>",
+                "<RSAKeyValue><Modulus>s+rl5mtcckCF9mEECD86L9UE2pbCR4CuiqDepwpiZCEflymQLNC3qNUPDlua9/kltyu6L489uimHRbEp4C7Gl7dDmaXVZLUVGkgUCZoRc8MrOw4+BiVAeQtCDdilPpA7DMN0bMfJAj3U4GuTU89/OWZMb9SYFfqEHM2e60PZHIU=</Modulus><Exponent>AQAB</Exponent><P>8qSTX42w2NaMCXL0PTZuacUFdJj93KopOJPD2q/JfmXSjXHV/IQK9YlCVKXHucqy8xcQgjkaKHqy3Rse14SZ7Q==</P><Q>vdJfDZ6ZIAQDx0sQbmbadHb6EOr8/oXo8B1CUSG0LqFZgDY7vBj17ujd6UhJWzhsg/5/3L+m4wDjMkUpOExZ+Q==</Q><DP>Av3Uc1Ej5QiAIX2xVS/enJ85Of7I4neWmoP33jJcoZpPxj6pDLv0BqLylmiU1c2R9z1JjtF1aRpaKi+zaaTQ4Q==</DP><DQ>Pv5yhv2MCYDrlBbIJCtD8gSN5lFllj3wWMcM/Am4VwU6w368Aicybo+fHUzc80XdVUx/OE3t30WrIEKtdD56WQ==</DQ><InverseQ>OcUQg0/kEGi9l2CgXCLKmQ1/1VVb+r89LXTO6rqi2wg5txkJIIXXePx7ce0Bh0eEnZzeSudwBLA3kqXmeAyYaw==</InverseQ><D>mnPL+zwtd7OmjTUJ5h6JUCi56wFDNWjl7gJeQd4rSzQYT4eRyrc/A4QsUbIYXkqXsyCpzExWvGsMQqrtfRQKzR53MBL3MQln5BjAUql2NqCkM2KT/D8Px5M21/TpMAycK4tGLOHgcCQRH1PQLHG1OfpfDASIzLwLgMjvMuHnIyE=</D></RSAKeyValue>"
+                );
+
+            Console.WriteLine("原始字符串：" + str);
+            //加密
+            byte[] enBytes = rsa.Encrypt(Encoding.UTF8.GetBytes(str));
+            Console.WriteLine("加密字符串：" + enBytes.ToHexString());
+            //解密
+            byte[] deBytes = rsa.Decrypt(enBytes);
+            Console.WriteLine("解密字符串：" + Encoding.UTF8.GetString(deBytes));
+            //私钥签名
+            string signStr = rsa.Sign(str);
+            Console.WriteLine("字符串签名：" + signStr);
+            //公钥验证签名
+            bool signVerify = rsa.Verify(str, signStr);
+            Console.WriteLine("验证签名：" + signVerify);
             Console.ReadKey();
         }
     }

src/NEEncrypts.Tests/NEEncryptsNET45.Test/Program.cs

@@ -12,17 +12,33 @@ namespace NEEncryptsNET45.Test
     {
         static void Main(string[] args)
         {
-            NEAES128EncryptImpl nE_AES128EncryptImpl = new NEAES128EncryptImpl(
-            new GBNewEnergy.Protocol.NEGlobalConfigs()
-            {
-                NEEncryptKey = "smallchi"
-            });
+            Default_NEAES128EncryptImpl nE_AES128EncryptImpl = new Default_NEAES128EncryptImpl("smallchi");
             string str = "aaasssddd123";
             var bytes = Encoding.UTF8.GetBytes(str);
             var encrypt = nE_AES128EncryptImpl.Encrypt(bytes);
             Console.WriteLine("原数据:" + str);
             Console.WriteLine("加密后:" + encrypt.ToHexString());
             Console.WriteLine("解密后:" + Encoding.UTF8.GetString(nE_AES128EncryptImpl.Decrypt(encrypt)));
+
+            Default_NERSAEncryptImpl_NET rsa = new Default_NERSAEncryptImpl_NET(Encoding.UTF8,
+                  "SHA256",
+                  "<RSAKeyValue><Modulus>s+rl5mtcckCF9mEECD86L9UE2pbCR4CuiqDepwpiZCEflymQLNC3qNUPDlua9/kltyu6L489uimHRbEp4C7Gl7dDmaXVZLUVGkgUCZoRc8MrOw4+BiVAeQtCDdilPpA7DMN0bMfJAj3U4GuTU89/OWZMb9SYFfqEHM2e60PZHIU=</Modulus><Exponent>AQAB</Exponent><P>8qSTX42w2NaMCXL0PTZuacUFdJj93KopOJPD2q/JfmXSjXHV/IQK9YlCVKXHucqy8xcQgjkaKHqy3Rse14SZ7Q==</P><Q>vdJfDZ6ZIAQDx0sQbmbadHb6EOr8/oXo8B1CUSG0LqFZgDY7vBj17ujd6UhJWzhsg/5/3L+m4wDjMkUpOExZ+Q==</Q><DP>Av3Uc1Ej5QiAIX2xVS/enJ85Of7I4neWmoP33jJcoZpPxj6pDLv0BqLylmiU1c2R9z1JjtF1aRpaKi+zaaTQ4Q==</DP><DQ>Pv5yhv2MCYDrlBbIJCtD8gSN5lFllj3wWMcM/Am4VwU6w368Aicybo+fHUzc80XdVUx/OE3t30WrIEKtdD56WQ==</DQ><InverseQ>OcUQg0/kEGi9l2CgXCLKmQ1/1VVb+r89LXTO6rqi2wg5txkJIIXXePx7ce0Bh0eEnZzeSudwBLA3kqXmeAyYaw==</InverseQ><D>mnPL+zwtd7OmjTUJ5h6JUCi56wFDNWjl7gJeQd4rSzQYT4eRyrc/A4QsUbIYXkqXsyCpzExWvGsMQqrtfRQKzR53MBL3MQln5BjAUql2NqCkM2KT/D8Px5M21/TpMAycK4tGLOHgcCQRH1PQLHG1OfpfDASIzLwLgMjvMuHnIyE=</D></RSAKeyValue>",
+                  "<RSAKeyValue><Modulus>s+rl5mtcckCF9mEECD86L9UE2pbCR4CuiqDepwpiZCEflymQLNC3qNUPDlua9/kltyu6L489uimHRbEp4C7Gl7dDmaXVZLUVGkgUCZoRc8MrOw4+BiVAeQtCDdilPpA7DMN0bMfJAj3U4GuTU89/OWZMb9SYFfqEHM2e60PZHIU=</Modulus><Exponent>AQAB</Exponent><P>8qSTX42w2NaMCXL0PTZuacUFdJj93KopOJPD2q/JfmXSjXHV/IQK9YlCVKXHucqy8xcQgjkaKHqy3Rse14SZ7Q==</P><Q>vdJfDZ6ZIAQDx0sQbmbadHb6EOr8/oXo8B1CUSG0LqFZgDY7vBj17ujd6UhJWzhsg/5/3L+m4wDjMkUpOExZ+Q==</Q><DP>Av3Uc1Ej5QiAIX2xVS/enJ85Of7I4neWmoP33jJcoZpPxj6pDLv0BqLylmiU1c2R9z1JjtF1aRpaKi+zaaTQ4Q==</DP><DQ>Pv5yhv2MCYDrlBbIJCtD8gSN5lFllj3wWMcM/Am4VwU6w368Aicybo+fHUzc80XdVUx/OE3t30WrIEKtdD56WQ==</DQ><InverseQ>OcUQg0/kEGi9l2CgXCLKmQ1/1VVb+r89LXTO6rqi2wg5txkJIIXXePx7ce0Bh0eEnZzeSudwBLA3kqXmeAyYaw==</InverseQ><D>mnPL+zwtd7OmjTUJ5h6JUCi56wFDNWjl7gJeQd4rSzQYT4eRyrc/A4QsUbIYXkqXsyCpzExWvGsMQqrtfRQKzR53MBL3MQln5BjAUql2NqCkM2KT/D8Px5M21/TpMAycK4tGLOHgcCQRH1PQLHG1OfpfDASIzLwLgMjvMuHnIyE=</D></RSAKeyValue>"
+                  );
+
+            Console.WriteLine("原始字符串：" + str);
+            //加密
+            byte[] enBytes = rsa.Encrypt(Encoding.UTF8.GetBytes(str));
+            Console.WriteLine("加密字符串：" + enBytes.ToHexString());
+            //解密
+            byte[] deBytes = rsa.Decrypt(enBytes);
+            Console.WriteLine("解密字符串：" + Encoding.UTF8.GetString(deBytes));
+            //私钥签名
+            string signStr = rsa.Sign(str);
+            Console.WriteLine("字符串签名：" + signStr);
+            //公钥验证签名
+            bool signVerify = rsa.Verify(str, signStr);
+            Console.WriteLine("验证签名：" + signVerify);
             Console.ReadKey();
         }
     }

src/NEEncrypts.Tests/NEEncryptsNETCore.Test/Program.cs

@@ -2,6 +2,7 @@
 using GBNewEnergy.Protocol.Extensions;
 using System;
 using System.Text;
+using System.Security.Cryptography;
 
 namespace NEEncryptsNETCore.Test
 {
@@ -9,17 +10,42 @@ namespace NEEncryptsNETCore.Test
     {
         static void Main(string[] args)
         {
-            NEAES128EncryptImpl nE_AES128EncryptImpl = new NEAES128EncryptImpl(
-             new GBNewEnergy.Protocol.NEGlobalConfigs()
-             {
-                 NEEncryptKey = "smallchi"
-             });
-            string str ="aaaaaa111111";
-            var bytes = Encoding.UTF8.GetBytes(str);
-            var encrypt = nE_AES128EncryptImpl.Encrypt(bytes);
-            Console.WriteLine("原数据:" + str);
-            Console.WriteLine("加密后:" + encrypt.ToHexString());
-            Console.WriteLine("解密后:" + Encoding.ASCII.GetString(nE_AES128EncryptImpl.Decrypt(encrypt)));
+            //Default_NEAES128EncryptImpl nE_AES128EncryptImpl = new Default_NEAES128EncryptImpl("smallchi");
+            string str = "aaaaaa111111";
+            //var bytes = Encoding.UTF8.GetBytes(str);
+            //var encrypt = nE_AES128EncryptImpl.Encrypt(bytes);
+            //Console.WriteLine("原数据:" + str);
+            //Console.WriteLine("加密后:" + encrypt.ToHexString());
+            //Console.WriteLine("解密后:" + Encoding.ASCII.GetString(nE_AES128EncryptImpl.Decrypt(encrypt)));
+
+            //NERSAEncryptImpl rsa = new NERSAEncryptImpl(
+            // new GBNewEnergy.Protocol.NEGlobalConfigs()
+            // {
+            //     NEEncryptRSAPublicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoQh0wEqx/R2H1v00IU12Oc30fosRC/frhH89L6G+fzeaqI19MYQhEPMU13wpeqRONCUta+2iC1sgCNQ9qGGf19yGdZUfueaB1Nu9rdueQKXgVurGHJ+5N71UFm+OP1XcnFUCK4wT5d7ZIifXxuqLehP9Ts6sNjhVfa+yU+VjF5HoIe69OJEPo7OxRZcRTe17khc93Ic+PfyqswQJJlY/bgpcLJQnM+QuHmxNtF7/FpAx9YEQsShsGpVo7JaKgLo+s6AFoJ4QldQKir2vbN9vcKRbG3piElPilWDpjXQkOJZhUloh/jd7QrKFimZFldJ1r6Q59QYUyGKZARUe0KZpMQIDAQAB",
+            //     NEEncryptRSAPrivateKey = "MIIEpAIBAAKCAQEAoQh0wEqx/R2H1v00IU12Oc30fosRC/frhH89L6G+fzeaqI19MYQhEPMU13wpeqRONCUta+2iC1sgCNQ9qGGf19yGdZUfueaB1Nu9rdueQKXgVurGHJ+5N71UFm+OP1XcnFUCK4wT5d7ZIifXxuqLehP9Ts6sNjhVfa+yU+VjF5HoIe69OJEPo7OxRZcRTe17khc93Ic+PfyqswQJJlY/bgpcLJQnM+QuHmxNtF7/FpAx9YEQsShsGpVo7JaKgLo+s6AFoJ4QldQKir2vbN9vcKRbG3piElPilWDpjXQkOJZhUloh/jd7QrKFimZFldJ1r6Q59QYUyGKZARUe0KZpMQIDAQABAoIBAQCRZLUlOUvjIVqYvhznRK1OG6p45s8JY1r+UnPIId2Bt46oSLeUkZvZVeCnfq9k0Bzb8AVGwVPhtPEDh73z3dEYcT/lwjLXAkyPB6gG5ZfI/vvC/k7JYV01+neFmktw2/FIJWjEMMF2dvLNZ/Pm4bX1Dz9SfD/45Hwr8wqrvRzvFZsj5qqOxv9RPAudOYwCwZskKp/GF+L+3Ycod1Wu98imzMZUH+L5dQuDGg3kvf3ljIAegTPoqYBg0imNPYY/EGoFKnbxlK5S5/5uAFb16dGJqAz3XQCz9Is/IWrOTu0etteqV2Ncs8uqPdjed+b0j8CMsr4U1xjwPQ8WwdaJtTkRAoGBANAndgiGZkCVcc9975/AYdgFp35W6D+hGQAZlL6DmnucUFdXbWa/x2rTSEXlkvgk9X/PxOptUYsLJkzysTgfDywZwuIXLm9B3oNmv3bVgPXsgDsvDfaHYCgz0nHK6NSrX2AeX3yO/dFuoZsuk+J+UyRigMqYj0wjmxUlqj183hinAoGBAMYMOBgF77OXRII7GAuEut/nBeh2sBrgyzR7FmJMs5kvRh6Ck8wp3ysgMvX4lxh1ep8iCw1R2cguqNATr1klOdsCTOE9RrhuvOp3JrYzuIAK6MpH/uBICy4w1rW2+gQySsHcH40r+tNaTFQ7dQ1tef//iy/IW8v8i0t+csztE1JnAoGABdtWYt8FOYP688+jUmdjWWSvVcq0NjYeMfaGTOX/DsNTL2HyXhW/Uq4nNnBDNmAz2CjMbZwt0y+5ICkj+2REVQVUinAEinTcAe5+LKXNPx4sbX3hcrJUbk0m+rSu4G0B/f5cyXBsi9wFCAzDdHgBduCepxSr04Sc9Hde1uQQi7kCgYB0U20HP0Vh+TG2RLuE2HtjVDD2L/CUeQEiXEHzjxXWnhvTg+MIAnggvpLwQwmMxkQ2ACr5sd/3YuCpB0bxV5o594nsqq9FWVYBaecFEjAGlWHSnqMoXWijwu/6X/VOTbP3VjH6G6ECT4GR4DKKpokIQrMgZ9DzaezvdOA9WesFdQKBgQCWfeOQTitRJ0NZACFUn3Fs3Rvgc9eN9YSWj4RtqkmGPMPvguWo+SKhlk3IbYjrRBc5WVOdoX8JXb2/+nAGhPCuUZckWVmZe5pMSr4EkNQdYeY8kOXGSjoTOUH34ZdKeS+e399BkBWIiXUejX/Srln0H4KoHnTWgxwNpTsBCgXu8Q==",
+            //     NERSAType = GBNewEnergy.Protocol.NEGlobalConfigs.RSAType.RSA2
+            // });
+
+            Default_NERSAEncryptImpl rsa = new Default_NERSAEncryptImpl(
+               Encoding.UTF8,
+               HashAlgorithmName.SHA256,
+               "<RSAKeyValue><Modulus>s+rl5mtcckCF9mEECD86L9UE2pbCR4CuiqDepwpiZCEflymQLNC3qNUPDlua9/kltyu6L489uimHRbEp4C7Gl7dDmaXVZLUVGkgUCZoRc8MrOw4+BiVAeQtCDdilPpA7DMN0bMfJAj3U4GuTU89/OWZMb9SYFfqEHM2e60PZHIU=</Modulus><Exponent>AQAB</Exponent><P>8qSTX42w2NaMCXL0PTZuacUFdJj93KopOJPD2q/JfmXSjXHV/IQK9YlCVKXHucqy8xcQgjkaKHqy3Rse14SZ7Q==</P><Q>vdJfDZ6ZIAQDx0sQbmbadHb6EOr8/oXo8B1CUSG0LqFZgDY7vBj17ujd6UhJWzhsg/5/3L+m4wDjMkUpOExZ+Q==</Q><DP>Av3Uc1Ej5QiAIX2xVS/enJ85Of7I4neWmoP33jJcoZpPxj6pDLv0BqLylmiU1c2R9z1JjtF1aRpaKi+zaaTQ4Q==</DP><DQ>Pv5yhv2MCYDrlBbIJCtD8gSN5lFllj3wWMcM/Am4VwU6w368Aicybo+fHUzc80XdVUx/OE3t30WrIEKtdD56WQ==</DQ><InverseQ>OcUQg0/kEGi9l2CgXCLKmQ1/1VVb+r89LXTO6rqi2wg5txkJIIXXePx7ce0Bh0eEnZzeSudwBLA3kqXmeAyYaw==</InverseQ><D>mnPL+zwtd7OmjTUJ5h6JUCi56wFDNWjl7gJeQd4rSzQYT4eRyrc/A4QsUbIYXkqXsyCpzExWvGsMQqrtfRQKzR53MBL3MQln5BjAUql2NqCkM2KT/D8Px5M21/TpMAycK4tGLOHgcCQRH1PQLHG1OfpfDASIzLwLgMjvMuHnIyE=</D></RSAKeyValue>",
+                "<RSAKeyValue><Modulus>s+rl5mtcckCF9mEECD86L9UE2pbCR4CuiqDepwpiZCEflymQLNC3qNUPDlua9/kltyu6L489uimHRbEp4C7Gl7dDmaXVZLUVGkgUCZoRc8MrOw4+BiVAeQtCDdilPpA7DMN0bMfJAj3U4GuTU89/OWZMb9SYFfqEHM2e60PZHIU=</Modulus><Exponent>AQAB</Exponent><P>8qSTX42w2NaMCXL0PTZuacUFdJj93KopOJPD2q/JfmXSjXHV/IQK9YlCVKXHucqy8xcQgjkaKHqy3Rse14SZ7Q==</P><Q>vdJfDZ6ZIAQDx0sQbmbadHb6EOr8/oXo8B1CUSG0LqFZgDY7vBj17ujd6UhJWzhsg/5/3L+m4wDjMkUpOExZ+Q==</Q><DP>Av3Uc1Ej5QiAIX2xVS/enJ85Of7I4neWmoP33jJcoZpPxj6pDLv0BqLylmiU1c2R9z1JjtF1aRpaKi+zaaTQ4Q==</DP><DQ>Pv5yhv2MCYDrlBbIJCtD8gSN5lFllj3wWMcM/Am4VwU6w368Aicybo+fHUzc80XdVUx/OE3t30WrIEKtdD56WQ==</DQ><InverseQ>OcUQg0/kEGi9l2CgXCLKmQ1/1VVb+r89LXTO6rqi2wg5txkJIIXXePx7ce0Bh0eEnZzeSudwBLA3kqXmeAyYaw==</InverseQ><D>mnPL+zwtd7OmjTUJ5h6JUCi56wFDNWjl7gJeQd4rSzQYT4eRyrc/A4QsUbIYXkqXsyCpzExWvGsMQqrtfRQKzR53MBL3MQln5BjAUql2NqCkM2KT/D8Px5M21/TpMAycK4tGLOHgcCQRH1PQLHG1OfpfDASIzLwLgMjvMuHnIyE=</D></RSAKeyValue>"
+               );
+
+            Console.WriteLine("原始字符串：" + str);
+            //加密
+            byte[] enBytes = rsa.Encrypt(Encoding.UTF8.GetBytes(str));
+            Console.WriteLine("加密字符串：" + enBytes.ToHexString());
+            //解密
+            byte[] deBytes = rsa.Decrypt(enBytes);
+            Console.WriteLine("解密字符串：" + Encoding.UTF8.GetString(deBytes));
+            //私钥签名
+            string signStr = rsa.Sign(str);
+            Console.WriteLine("字符串签名：" + signStr);
+            //公钥验证签名
+            bool signVerify = rsa.Verify(str, signStr);
+            Console.WriteLine("验证签名：" + signVerify);
             Console.ReadKey();
         }
     }