Merge pull request #4 from myloveCc/dev

Add DES encrypt and decrypt.

Author: myloveCc

src/NETCore.Encrypt/EncryptProvider.cs

@@ -12,20 +12,7 @@ namespace NETCore.Encrypt
 {
     public class EncryptProvider
     {
-        #region AES
-
-        /// <summary>
-        /// create ase key
-        /// </summary>
-        /// <returns></returns>
-        public static AESKey CreateAesKey()
-        {
-            return new AESKey()
-            {
-                Key = GetRandomStr(32),
-                IV = GetRandomStr(16)
-            };
-        }
+        #region Common
 
         /// <summary>
         /// Generate a random key
@@ -51,6 +38,24 @@ private static string GetRandomStr(int length)
             return num.ToString();
         }
 
+
+        #endregion
+
+        #region AES
+
+        /// <summary>
+        /// Create ase key
+        /// </summary>
+        /// <returns></returns>
+        public static AESKey CreateAesKey()
+        {
+            return new AESKey()
+            {
+                Key = GetRandomStr(32),
+                IV = GetRandomStr(16)
+            };
+        }
+
         /// <summary>  
         /// AES encrypt
         /// </summary>  
@@ -202,7 +207,7 @@ public static string AESEncrypt(string data, string key)
         /// <summary>  
         /// AES decrypt( no IV)  
         /// </summary>  
-        /// <param name="data">encrypted data</param>  
+        /// <param name="data">Encrypted data</param>  
         /// <param name="key">Key, requires 32 bits</param>  
         /// <returns>Decrypted string</returns>  
         public static string AESDecrypt(string data, string key)
@@ -230,8 +235,8 @@ public static string AESDecrypt(string data, string key)
                     {
                         try
                         {
-                            byte[] tmp = new byte[encryptedBytes.Length + 32];
-                            int len = cryptoStream.Read(tmp, 0, encryptedBytes.Length + 32);
+                            byte[] tmp = new byte[encryptedBytes.Length ];
+                            int len = cryptoStream.Read(tmp, 0, encryptedBytes.Length);
                             byte[] ret = new byte[len];
                             Array.Copy(tmp, 0, ret, 0, len);
                             return Encoding.UTF8.GetString(ret);
@@ -246,6 +251,101 @@ public static string AESDecrypt(string data, string key)
         }
         #endregion
 
+        #region DES
+
+        /// <summary>
+        /// Create des key
+        /// </summary>
+        /// <returns></returns>
+        public static string CreateDesKey()
+        {
+            return GetRandomStr(24);
+        }
+
+        /// <summary>  
+        /// DES encrypt
+        /// </summary>  
+        /// <param name="data">Raw data</param>  
+        /// <param name="key">Key, requires 24 bits</param>  
+        /// <returns>Encrypted string</returns>  
+        public static string DESEncrypt(string data, string key)
+        {
+            Check.Argument.IsNotEmpty(data, nameof(data));
+            Check.Argument.IsNotEmpty(key, nameof(key));
+            Check.Argument.IsNotOutOfRange(key.Length, 24, 24, nameof(key));
+
+            using (MemoryStream mStream = new MemoryStream())
+            {
+                using (TripleDES des = TripleDES.Create())
+                {
+                    byte[] plainBytes = Encoding.UTF8.GetBytes(data);
+                    Byte[] bKey = new Byte[24];
+                    Array.Copy(Encoding.UTF8.GetBytes(key.PadRight(bKey.Length)), bKey, bKey.Length);
+
+                    des.Mode = CipherMode.ECB;
+                    des.Padding = PaddingMode.PKCS7;
+                    des.Key = bKey;
+                    using (CryptoStream cryptoStream = new CryptoStream(mStream, des.CreateEncryptor(), CryptoStreamMode.Write))
+                    {
+                        try
+                        {
+                            cryptoStream.Write(plainBytes, 0, plainBytes.Length);
+                            cryptoStream.FlushFinalBlock();
+                            return Convert.ToBase64String(mStream.ToArray());
+                        }
+                        catch (Exception ex)
+                        {
+                            return null;
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>  
+        /// DES decrypt
+        /// </summary>  
+        /// <param name="data">Encrypted data</param>  
+        /// <param name="key">Key, requires 24 bits</param>  
+        /// <returns>Decrypted string</returns>  
+        public static string DESDecrypt(string data, string key)
+        {
+            Check.Argument.IsNotEmpty(data, nameof(data));
+            Check.Argument.IsNotEmpty(key, nameof(key));
+            Check.Argument.IsNotOutOfRange(key.Length, 24, 24, nameof(key));
+
+            Byte[] encryptedBytes = Convert.FromBase64String(data);
+            Byte[] bKey = new Byte[24];
+            Array.Copy(Encoding.UTF8.GetBytes(key.PadRight(bKey.Length)), bKey, bKey.Length);
+
+            using (MemoryStream mStream = new MemoryStream(encryptedBytes))
+            {
+                using (TripleDES des = TripleDES.Create())
+                {
+                    des.Mode = CipherMode.ECB;
+                    des.Padding = PaddingMode.PKCS7;
+                    des.Key = bKey;
+                    using (CryptoStream cryptoStream = new CryptoStream(mStream, des.CreateDecryptor(), CryptoStreamMode.Read))
+                    {
+                        try
+                        {
+                            byte[] tmp = new byte[encryptedBytes.Length];
+                            int len = cryptoStream.Read(tmp, 0, encryptedBytes.Length);
+                            byte[] ret = new byte[len];
+                            Array.Copy(tmp, 0, ret, 0, len);
+                            return Encoding.UTF8.GetString(ret);
+                        }
+                        catch
+                        {
+                            return null;
+                        }
+                    }
+                }
+            }
+        }
+
+        #endregion
+
         #region RSA
         /// <summary>
         /// RSA encrypt 
@@ -636,7 +736,6 @@ private static string CreateMachineKey(int length)
 
         #region Base64
 
-
         #region Base64加密解密
         /// <summary>
         /// Base64 encrypt

src/NETCore.Encrypt/Extensions/Internal/RsaKeyExtensions.cs

@@ -41,7 +41,7 @@ internal static void FromJsonString(this RSA rsa, string jsonString)
             }
             catch
             {
-                throw new Exception("Invalid XML RSA key.");
+                throw new Exception("Invalid Json RSA key.");
             }
             rsa.ImportParameters(parameters);
         }

test/NETCore.Encrypt.Tests/DES_Test.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+using NETCore.Encrypt;
+
+namespace NETCore.Encrypt.Tests
+{
+    public class DES_Test
+    {
+        private readonly string _Key;
+
+        public DES_Test()
+        {
+            _Key = EncryptProvider.CreateDesKey();
+        }
+
+        [Fact(DisplayName = "DES ke test")]
+        public void Cretea_DESKey_Test()
+        {
+
+            var DESKey = EncryptProvider.CreateDesKey();
+
+            //Assert
+            Assert.NotNull(DESKey);
+            Assert.Equal(24, DESKey.Length);
+        }
+
+
+        [Fact(DisplayName = "DES encrypt with empty data test")]
+        public void DES_Encryt_EmptyData_Fail_Test()
+        {
+            var srcString = string.Empty;
+            //Assert
+            Assert.Throws<ArgumentException>(() => EncryptProvider.DESDecrypt(srcString, _Key));
+        }
+
+
+        [Fact(DisplayName = "DES encrypt with error key test")]
+        public void DES_Encrypt_ErrorKey_Fail_Test()
+        {
+            var key = "1hyhuo";
+            var srcString = "test DES encrypt";
+
+            //Assert
+            Assert.Throws<ArgumentOutOfRangeException>(() => EncryptProvider.DESEncrypt(srcString, key));
+        }
+
+        [Fact(DisplayName = "DES decrypt success test")]
+        public void DES_Decryt_Success_Test()
+        {
+            var srcString = "test DES encrypt";
+
+            //Ack
+            var encrypted = EncryptProvider.DESEncrypt(srcString, _Key);
+            var decrypted = EncryptProvider.DESDecrypt(encrypted, _Key);
+
+            //Assert
+            Assert.NotEmpty(encrypted);
+            Assert.NotEmpty(decrypted);
+            Assert.Equal(srcString, decrypted);
+        }
+
+        [Fact(DisplayName = "DES decrypt with empty data test")]
+        public void DES_Decrypt_EmptyData_Fail_Test()
+        {
+            var srcString = string.Empty;
+
+            //Assert
+            Assert.Throws<ArgumentException>(() => EncryptProvider.DESDecrypt(srcString, _Key));
+        }
+
+        [Fact(DisplayName = "DES decrypt with error key test")]
+        public void DES_Decrypt_ErrorKey_Fail_Test()
+        {
+            var key = "dfafa";  //must be 24 bit
+            var srcString = "test DES encrypt";
+
+            //Assert
+            Assert.Throws<ArgumentOutOfRangeException>(() => EncryptProvider.DESDecrypt(srcString, key));
+        }
+    }
+}