From af174226e705f4be76c07e450048f81d71bf32ce Mon Sep 17 00:00:00 2001
From: SmallChi <564952747@qq.com>
Date: Mon, 11 Jun 2018 19:33:06 +0800
Subject: [PATCH] =?UTF-8?q?1.=E6=B7=BB=E5=8A=A0AES=E5=92=8CRSA=E9=BB=98?=
 =?UTF-8?q?=E8=AE=A4=E5=AE=9E=E7=8E=B0=202.=E6=B7=BB=E5=8A=A0AES=E5=92=8CR?=
 =?UTF-8?q?SA=E5=9C=A8=E4=B8=8D=E5=90=8C=E7=8E=AF=E5=A2=83=E4=B8=8B?=
 =?UTF-8?q?=E6=B5=8B=E8=AF=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../NEPackageTest.cs                          |   2 +-
 ...Impl.cs => Default_NEAES128EncryptImpl.cs} |  33 +--
 .../NEEncrypts/Default_NERSAEncryptImpl.cs    | 193 ++++++++++++++++++
 .../Default_NERSAEncryptImpl_NET.cs           |  90 ++++++++
 .../NEEncrypts/NEAESBase.cs                   |  14 ++
 .../NEEncrypts/NERSABase.cs                   |  45 ++++
 .../NEEncrypts/NERSAEncryptImpl.cs            |  27 ---
 src/GBNewEnergy.Protocol/NEGlobalConfigs.cs   |   6 +-
 .../NEEncryptsNET4.Test/Program.cs            |  32 ++-
 .../NEEncryptsNET45.Test/Program.cs           |  26 ++-
 .../NEEncryptsNETCore.Test/Program.cs         |  48 ++++-
 11 files changed, 444 insertions(+), 72 deletions(-)
 rename src/GBNewEnergy.Protocol/NEEncrypts/{NEAES128EncryptImpl.cs => Default_NEAES128EncryptImpl.cs} (65%)
 create mode 100644 src/GBNewEnergy.Protocol/NEEncrypts/Default_NERSAEncryptImpl.cs
 create mode 100644 src/GBNewEnergy.Protocol/NEEncrypts/Default_NERSAEncryptImpl_NET.cs
 create mode 100644 src/GBNewEnergy.Protocol/NEEncrypts/NEAESBase.cs
 create mode 100644 src/GBNewEnergy.Protocol/NEEncrypts/NERSABase.cs
 delete mode 100644 src/GBNewEnergy.Protocol/NEEncrypts/NERSAEncryptImpl.cs

diff --git a/src/GBNewEnergy.Protocol.Test/NEPackageTest.cs b/src/GBNewEnergy.Protocol.Test/NEPackageTest.cs
index df279c4..a75962e 100644
--- a/src/GBNewEnergy.Protocol.Test/NEPackageTest.cs
+++ b/src/GBNewEnergy.Protocol.Test/NEPackageTest.cs
@@ -14,7 +14,7 @@ namespace GBNewEnergy.Protocol.Test
     {
         private readonly NEGlobalConfigs NEGlobalConfigs = new NEGlobalConfigs()
         {
-             NEEncryptKey="smallchi" 
+
         };
         #region 车辆登入
         [Fact]
diff --git a/src/GBNewEnergy.Protocol/NEEncrypts/NEAES128EncryptImpl.cs b/src/GBNewEnergy.Protocol/NEEncrypts/Default_NEAES128EncryptImpl.cs
similarity index 65%
rename from src/GBNewEnergy.Protocol/NEEncrypts/NEAES128EncryptImpl.cs
rename to src/GBNewEnergy.Protocol/NEEncrypts/Default_NEAES128EncryptImpl.cs
index 8508e70..8166b75 100644
--- a/src/GBNewEnergy.Protocol/NEEncrypts/NEAES128EncryptImpl.cs
+++ b/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())
diff --git a/src/GBNewEnergy.Protocol/NEEncrypts/Default_NERSAEncryptImpl.cs b/src/GBNewEnergy.Protocol/NEEncrypts/Default_NERSAEncryptImpl.cs
new file mode 100644
index 0000000..b707eb8
--- /dev/null
+++ b/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
+}
diff --git a/src/GBNewEnergy.Protocol/NEEncrypts/Default_NERSAEncryptImpl_NET.cs b/src/GBNewEnergy.Protocol/NEEncrypts/Default_NERSAEncryptImpl_NET.cs
new file mode 100644
index 0000000..beb0094
--- /dev/null
+++ b/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;
+            }
+        }
+    }
+}
diff --git a/src/GBNewEnergy.Protocol/NEEncrypts/NEAESBase.cs b/src/GBNewEnergy.Protocol/NEEncrypts/NEAESBase.cs
new file mode 100644
index 0000000..3bd8f34
--- /dev/null
+++ b/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);
+    }
+}
diff --git a/src/GBNewEnergy.Protocol/NEEncrypts/NERSABase.cs b/src/GBNewEnergy.Protocol/NEEncrypts/NERSABase.cs
new file mode 100644
index 0000000..cdc3c18
--- /dev/null
+++ b/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);
+    }
+}
diff --git a/src/GBNewEnergy.Protocol/NEEncrypts/NERSAEncryptImpl.cs b/src/GBNewEnergy.Protocol/NEEncrypts/NERSAEncryptImpl.cs
deleted file mode 100644
index 27118bd..0000000
--- a/src/GBNewEnergy.Protocol/NEEncrypts/NERSAEncryptImpl.cs
+++ /dev/null
@@ -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();
-        }
-    }
-}
diff --git a/src/GBNewEnergy.Protocol/NEGlobalConfigs.cs b/src/GBNewEnergy.Protocol/NEGlobalConfigs.cs
index 09ed2bb..c2f4f2e 100644
--- a/src/GBNewEnergy.Protocol/NEGlobalConfigs.cs
+++ b/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”表示无效
diff --git a/src/NEEncrypts.Tests/NEEncryptsNET4.Test/Program.cs b/src/NEEncrypts.Tests/NEEncryptsNET4.Test/Program.cs
index 4ca66ac..aa38ed5 100644
--- a/src/NEEncrypts.Tests/NEEncryptsNET4.Test/Program.cs
+++ b/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();
         }
     }
diff --git a/src/NEEncrypts.Tests/NEEncryptsNET45.Test/Program.cs b/src/NEEncrypts.Tests/NEEncryptsNET45.Test/Program.cs
index 59f7acc..ec6bed1 100644
--- a/src/NEEncrypts.Tests/NEEncryptsNET45.Test/Program.cs
+++ b/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();
         }
     }
diff --git a/src/NEEncrypts.Tests/NEEncryptsNETCore.Test/Program.cs b/src/NEEncrypts.Tests/NEEncryptsNETCore.Test/Program.cs
index 1fad826..dcaadf5 100644
--- a/src/NEEncrypts.Tests/NEEncryptsNETCore.Test/Program.cs
+++ b/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();
         }
     }