EncryptFac 加解密小工具

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    public interface IEncrypt

    {

        string Encrypt(EncryptInfo model);

        string Dencrypt(EncryptInfo model);

        string Check(EncryptInfo model);

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    public class EncryptInfo

    {

        public EncryptInfo(string source)

        {

            this.Source = source;

            this.Encode = Encoding.Default;

        }

        public EncryptInfo(string source, Encoding encode)

        {

            this.Source = source;

            this.Encode = encode;

        }

        public string Source { get; set; }

        public string Key { get; set; }

        public string Iv { get; set; }

        public Encoding Encode { get; set; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    /// <summary>

    /// key的长度必须为24位

    /// </summary>

    public class Encrypt3DES : IEncrypt

    {

        public string Encrypt(EncryptInfo model)

        {

            TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider();

            DES.Key = model.Encode.GetBytes(model.Key);

            DES.Mode = CipherMode.ECB;

            ICryptoTransform DESEncrypt = DES.CreateEncryptor();

            byte[] Buffer = model.Encode.GetBytes(model.Source);

            return Convert.ToBase64String(DESEncrypt.TransformFinalBlock(Buffer, , Buffer.Length));

        }

        public string Dencrypt(EncryptInfo model)

        {

            TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider();

            DES.Key = model.Encode.GetBytes(model.Key);

            DES.Mode = CipherMode.ECB;

            DES.Padding = System.Security.Cryptography.PaddingMode.PKCS7;

            ICryptoTransform DESDecrypt = DES.CreateDecryptor();

            byte[] Buffer = Convert.FromBase64String(model.Source);

            return model.Encode.GetString(DESDecrypt.TransformFinalBlock(Buffer, , Buffer.Length));

        }

        public string Check(EncryptInfo model)

        {

            StringBuilder sb = new StringBuilder();

            if (string.IsNullOrEmpty(model.Key))

                sb.Append("秘钥不能为空");

            else if (model.Key.Length != )

                sb.Append("秘钥长度必须为24");

            return sb.ToString();

        }

    }

}

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    /// <summary>

    /// 原名Rijndael

    /// key 为8 16 24 32位

    /// IV 为16位

    /// </summary>

    public class EncryptAES : IEncrypt

    {

        public string Encrypt(EncryptInfo model)

        {

            //Rijndael rijndael = Rijndael.Create();

            //rijndael.IV = model.Encode.GetBytes(model.Iv);

            //rijndael.Key = model.Encode.GetBytes(model.Key);

            //Byte[] bytes = model.Encode.GetBytes(model.Source);

            //string result = "";

            //using (ICryptoTransform transform = rijndael.CreateEncryptor())

            //{

            //    byte[] output = transform.TransformFinalBlock(bytes, 0, bytes.Length);

            //    result = Convert.ToBase64String(output);

            //}

            //return result;

            Byte[] plainBytes = model.Encode.GetBytes(model.Source);

            Byte[] bKey = new Byte[];

            Array.Copy(model.Encode.GetBytes(model.Key.PadRight(bKey.Length)), bKey, bKey.Length);

            Byte[] bVector = new Byte[];

            Array.Copy(model.Encode.GetBytes(model.Iv.PadRight(bVector.Length)), bVector, bVector.Length);

            Byte[] Cryptograph = null;

            Rijndael Aes = Rijndael.Create();

            using (MemoryStream Memory = new MemoryStream())

            {

                using (CryptoStream Encryptor = new CryptoStream(Memory,

                 Aes.CreateEncryptor(bKey, bVector),

                 CryptoStreamMode.Write))

                {

                    Encryptor.Write(plainBytes, , plainBytes.Length);

                    Encryptor.FlushFinalBlock();

                    Cryptograph = Memory.ToArray();

                }

            }

            return Convert.ToBase64String(Cryptograph);

        }

        public string Dencrypt(EncryptInfo model)

        {

            //Rijndael rijndael = Rijndael.Create();

            //rijndael.Key = model.Encode.GetBytes(model.Key);

            //rijndael.IV = model.Encode.GetBytes(model.Iv);

            //byte[] bytes = model.Encode.GetBytes(model.Source);

            //using (ICryptoTransform transform2 = rijndael.CreateDecryptor())

            //{

            //    byte[] decryption = transform2.TransformFinalBlock(bytes, 0, bytes.Length);

            //    return model.Encode.GetString(decryption);

            //}

            Byte[] encryptedBytes = Convert.FromBase64String(model.Source);

            Byte[] bKey = new Byte[];

            Array.Copy(model.Encode.GetBytes(model.Key.PadRight(bKey.Length)), bKey, bKey.Length);

            Byte[] bVector = new Byte[];

            Array.Copy(model.Encode.GetBytes(model.Iv.PadRight(bVector.Length)), bVector, bVector.Length);

            Byte[] original = null;

            Rijndael Aes = Rijndael.Create();

            using (MemoryStream Memory = new MemoryStream(encryptedBytes))

            {

                using (CryptoStream Decryptor = new CryptoStream(Memory,

                Aes.CreateDecryptor(bKey, bVector),

                CryptoStreamMode.Read))

                {

                    using (MemoryStream originalMemory = new MemoryStream())

                    {

                        Byte[] Buffer = new Byte[];

                        Int32 readBytes = ;

                        while ((readBytes = Decryptor.Read(Buffer, , Buffer.Length)) > )

                        {

                            originalMemory.Write(Buffer, , readBytes);

                        }

                        original = originalMemory.ToArray();

                    }

                }

            }

            return model.Encode.GetString(original);

        }

        public string Check(EncryptInfo model)

        {

            StringBuilder sb = new StringBuilder();

            if (string.IsNullOrEmpty(model.Key))

                sb.Append("秘钥不能为空,");

            else if (model.Key.Length != )

                sb.Append("秘钥长度必须为32,");

            if (!string.IsNullOrEmpty(model.Iv) && model.Iv.Length != )

                sb.Append("向量长度必须为16,");

            return sb.ToString();

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    public class EncryptBase64 : IEncrypt

    {

        public string Encrypt(EncryptInfo model)

        {

            return Convert.ToBase64String(model.Encode.GetBytes(model.Source));

        }

        public string Dencrypt(EncryptInfo model)

        {

            return model.Encode.GetString(Convert.FromBase64String(model.Source));

        }

        public string Check(EncryptInfo model)

        {

            return "";

        }

    }

}

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    /// <summary>

    /// key 为8位

    /// IV 为8位

    /// </summary>

    public class EncryptDES : IEncrypt

    {

        public string Encrypt(EncryptInfo model)

        {

            string result = "";

            byte[] byKey = model.Encode.GetBytes(model.Key);

            byte[] byIV = model.Encode.GetBytes(model.Iv);

            DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();

            int i = cryptoProvider.KeySize;

            using (MemoryStream ms = new MemoryStream())

            using (CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateEncryptor(byKey, byIV), CryptoStreamMode.Write))

            using (StreamWriter sw = new StreamWriter(cst))

            {

                sw.Write(model.Source);

                sw.Flush();

                cst.FlushFinalBlock();

                sw.Flush();

                result = Convert.ToBase64String(ms.GetBuffer(), , (int)ms.Length);

            }

            return result;

        }

        public string Dencrypt(EncryptInfo model)

        {

            string result = "";

            byte[] byKey = model.Encode.GetBytes(model.Key);

            byte[] byIV = model.Encode.GetBytes(model.Iv);

            byte[] byEnc = Convert.FromBase64String(model.Source);

            DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();

            using (MemoryStream ms = new MemoryStream(byEnc))

            using (CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateDecryptor(byKey, byIV), CryptoStreamMode.Read))

            using (StreamReader sr = new StreamReader(cst))

                result = sr.ReadToEnd();

            return result;

        }

        public string Check(EncryptInfo model)

        {

            StringBuilder sb = new StringBuilder();

            if (string.IsNullOrEmpty(model.Key))

                sb.Append("秘钥不能为空,");

            else if (model.Key.Length != )

                sb.Append("秘钥长度必须为8,");

            if (!string.IsNullOrEmpty(model.Iv) && model.Iv.Length != )

                sb.Append("向量长度必须为8,");

            return sb.ToString();

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Web;

namespace EncryptBLL

{

    public class EncryptEncode : IEncrypt

    {

        public string Encrypt(EncryptInfo model)

        {

            return HttpUtility.UrlEncode(model.Source, model.Encode);

        }

        public string Dencrypt(EncryptInfo model)

        {

            return HttpUtility.UrlDecode(model.Source, model.Encode);

        }

        public string Check(EncryptInfo model)

        {

            return "";

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    public class EncryptMD5_16 : IEncrypt

    {

        public string Encrypt(EncryptInfo model)

        {

            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();

            string result = BitConverter.ToString(md5.ComputeHash(model.Encode.GetBytes(model.Source)), , );

            result = result.Replace("-", "");

            return result;

        }

        public string Dencrypt(EncryptInfo model)

        {

            throw new Exception("该方法没有实现方式");

        }

        public string Check(EncryptInfo model)

        {

            return "";

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    public class EncryptMD5_32 : IEncrypt

    {

        public string Encrypt(EncryptInfo model)

        {

            byte[] result = model.Encode.GetBytes(model.Source);

            MD5 md5 = new MD5CryptoServiceProvider();

            byte[] output = md5.ComputeHash(result);

            return BitConverter.ToString(output).Replace("-", "");

        }

        public string Dencrypt(EncryptInfo model)

        {

            throw new Exception("该方法没有实现方式");

        }

        public string Check(EncryptInfo model)

        {

            return "";

        }

    }

}

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    /// <summary>

    /// IV为8位

    /// key为5-16位

    /// </summary>

    public class EncryptRC2 : IEncrypt

    {

        public string Encrypt(EncryptInfo model)

        {

            byte[] bytesIV = model.Encode.GetBytes(model.Iv);

            RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();

            byte[] bytesInput = model.Encode.GetBytes(model.Source);

            using (MemoryStream ms = new MemoryStream())

            using (CryptoStream cs = new CryptoStream(ms, rc2.CreateEncryptor(model.Encode.GetBytes(model.Key),

                 bytesIV), CryptoStreamMode.Write))

            {

                cs.Write(bytesInput, , bytesInput.Length);

                cs.FlushFinalBlock();

                var result = Convert.ToBase64String(ms.ToArray());

                return result;

            }

        }

        public string Dencrypt(EncryptInfo model)

        {

            byte[] bytesIV = model.Encode.GetBytes(model.Iv);

            RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();

            byte[] bytesInput = Convert.FromBase64String(model.Source);

            using (MemoryStream ms = new MemoryStream())

            using (CryptoStream cs = new CryptoStream(ms, rc2.CreateDecryptor(Encoding.Default.GetBytes(model.Key),

                     bytesIV), CryptoStreamMode.Write))

            {

                cs.Write(bytesInput, , bytesInput.Length);

                cs.FlushFinalBlock();

                string result = model.Encode.GetString(ms.ToArray());

                return result;

            }

        }

        public string Check(EncryptInfo model)

        {

            StringBuilder sb = new StringBuilder();

            if (string.IsNullOrEmpty(model.Key))

                sb.Append("秘钥不能为空,");

            else if (model.Key.Length <  || model.Key.Length > )

                sb.Append("秘钥长度必须为5-16之间,");

            if (!string.IsNullOrEmpty(model.Iv) && model.Iv.Length != )

                sb.Append("向量长度必须为8,");

            return sb.ToString();

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    /// <summary>

    /// 生成的密文每次都会不同

    /// </summary>

    public class EncryptRSA : IEncrypt

    {

        public string Encrypt(EncryptInfo model)

        {

            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

            byte[] cipherbytes;

            rsa.FromXmlString(model.Key);

            cipherbytes = rsa.Encrypt(model.Encode.GetBytes(model.Source), false);

            return Convert.ToBase64String(cipherbytes);

        }

        public string Dencrypt(EncryptInfo model)

        {

            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

            byte[] cipherbytes;

            rsa.FromXmlString(model.Key);

            cipherbytes = rsa.Decrypt(Convert.FromBase64String(model.Source), false);

            return model.Encode.GetString(cipherbytes);

        }

        public string Check(EncryptInfo model)

        {

            return "";

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace EncryptBLL

{

    public class EncryptSHA1 : IEncrypt

    {

        public string Encrypt(EncryptInfo model)

        {

            SHA1 sha1 = new SHA1CryptoServiceProvider();

            byte[] bytes = model.Encode.GetBytes(model.Source);

            byte[] output = sha1.ComputeHash(bytes);

            string result = BitConverter.ToString(output).Replace("-", "");

            return result;

        }

        public string Dencrypt(EncryptInfo model)

        {

            throw new Exception("该方法没有实现方式");

        }

        public string Check(EncryptInfo model)

        {

            return "";

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using EncryptBLL;

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace EncryptBLL.Tests

{

    [TestClass()]

    public class EncryptRSATests

    {

        [TestMethod()]

        public void EncryptTest()

        {

            IEncrypt encrypt = new EncryptRSA();

            EncryptInfo pwd = new EncryptInfo("", Encoding.UTF8);

            //pwd.Key = @"<RSAKeyValue><Modulus>5m9m14XH3oqLJ8bNGw9e4rGpXpcktv9MSkHSVFVMjHbfv+SJ5v0ubqQxa5YjLN4vc49z7SVju8s0X4gZ6AzZTn06jzWOgyPRV54Q4I0DCYadWW4Ze3e+BOtwgVU1Og3qHKn8vygoj40J6U85Z/PTJu3hN1m75Zr195ju7g9v4Hk=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";

            //var result = encrypt.Encrypt(pwd);

            //var result1 = new EncryptSHA1().Encrypt(pwd);

            //pwd.Source = "us=张三&xin=113";

            //var result2 = new EncryptEncode().Encrypt(pwd);

            //Assert.AreEqual("us%3d%e5%bc%a0%e4%b8%89%26xin%3d113", result2);

            //Assert.AreEqual("7c4a8d09ca3762af61e59520943dc26494f8941b", result1.ToLower());

            pwd.Key = "12345678901234567890ab";

            pwd.Iv = "1234567890abcd";

            var temp = new EncryptAES().Encrypt(pwd);

            pwd.Source = temp;

            var temp2 = new EncryptAES().Dencrypt(pwd);

        }

        [TestMethod()]

        public void DencryptTest()

        {

            IEncrypt encrypt = new EncryptRSA();

            EncryptInfo pwd = new EncryptInfo("QNKz7wMTPJt0UVfOtat0e/az3DrBs00kybYWaC2dhPn+dGATC7xkyBPXitiZfJHxcefunio4aW1Oc3BlC3QIggo/XT2cRE3lRsClOOxyrrTHWmynYkF4pSKr/xIl64fdjm+taOAJHjdeg6iW5V4AMEpnYLNwLoIQCwzNU5+o5yM=", Encoding.UTF8);

            pwd.Key = @"<RSAKeyValue><Modulus>5m9m14XH3oqLJ8bNGw9e4rGpXpcktv9MSkHSVFVMjHbfv+SJ5v0ubqQxa5YjLN4vc49z7SVju8s0X4gZ6AzZTn06jzWOgyPRV54Q4I0DCYadWW4Ze3e+BOtwgVU1Og3qHKn8vygoj40J6U85Z/PTJu3hN1m75Zr195ju7g9v4Hk=</Modulus><Exponent>AQAB</Exponent><P>/hf2dnK7rNfl3lbqghWcpFdu778hUpIEBixCDL5WiBtpkZdpSw90aERmHJYaW2RGvGRi6zSftLh00KHsPcNUMw==</P><Q>6Cn/jOLrPapDTEp1Fkq+uz++1Do0eeX7HYqi9rY29CqShzCeI7LEYOoSwYuAJ3xA/DuCdQENPSoJ9KFbO4Wsow==</Q><DP>ga1rHIJro8e/yhxjrKYo/nqc5ICQGhrpMNlPkD9n3CjZVPOISkWF7FzUHEzDANeJfkZhcZa21z24aG3rKo5Qnw==</DP><DQ>MNGsCB8rYlMsRZ2ek2pyQwO7h/sZT8y5ilO9wu08Dwnot/7UMiOEQfDWstY3w5XQQHnvC9WFyCfP4h4QBissyw==</DQ><InverseQ>EG02S7SADhH1EVT9DD0Z62Y0uY7gIYvxX/uq+IzKSCwB8M2G7Qv9xgZQaQlLpCaeKbux3Y59hHM+KpamGL19Kg==</InverseQ><D>vmaYHEbPAgOJvaEXQl+t8DQKFT1fudEysTy31LTyXjGu6XiltXXHUuZaa2IPyHgBz0Nd7znwsW/S44iql0Fen1kzKioEL3svANui63O3o5xdDeExVM6zOf1wUUh/oldovPweChyoAdMtUzgvCbJk1sYDJf++Nr0FeNW1RB1XG30=</D></RSAKeyValue>";

            var result = encrypt.Dencrypt(pwd);

            Assert.AreEqual("", result);

        }

    }

}

using EncryptBLL;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace EncryptFac

{

    public partial class Form1 : Form

    {

        static List<string> encrypts = new List<string> {

            "3DES","AES","Base64","DES","Encode","MD5_16","MD5_32","RC2","RSA","SHA1"

        };

        static List<string> encodes = new List<string> {

            "utf-8","gb2312","default","ascii"

        };

        public Form1()

        {

            InitializeComponent();

            this.cbxType.DataSource = encrypts;

            this.cbxEncode.DataSource = encodes;

        }

        private void btnEncrypt_Click(object sender, EventArgs e)

        {

            try

            {

                EncryptInfo encrypt = new EncryptInfo(this.txtSource.Text, Encoding.GetEncoding(this.cbxEncode.SelectedValue.ToString()));

                encrypt.Iv = this.txtIV.Text;

                encrypt.Key = this.txtKey.Text;

                IEncrypt obj = (IEncrypt)CreateInstance("EncryptBLL.Encrypt" + this.cbxType.SelectedValue);

                string checkeMsg = obj.Check(encrypt);

                if (string.Empty != checkeMsg)

                {

                    MessageBox.Show(checkeMsg);

                    return;

                }

                this.txtPassword.Text = obj.Encrypt(encrypt);

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.Message);

            }

        }

        private void btnDecrypt_Click(object sender, EventArgs e)

        {

            try

            {

                EncryptInfo encrypt = new EncryptInfo(this.txtSource.Text, Encoding.GetEncoding(this.cbxEncode.SelectedValue.ToString()));

                encrypt.Iv = this.txtIV.Text;

                encrypt.Key = this.txtKey.Text;

                IEncrypt obj = (IEncrypt)CreateInstance("EncryptBLL.Encrypt" + this.cbxType.SelectedValue);

                string checkeMsg = obj.Check(encrypt);

                if (string.Empty != checkeMsg)

                {

                    MessageBox.Show(checkeMsg);

                    return;

                }

                this.txtPassword.Text = obj.Dencrypt(encrypt);

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.Message);

            }

        }

        private void cbxType_SelectedIndexChanged(object sender, EventArgs e)

        {

            this.txtPassword.Text = "";

        }

        public object CreateInstance(string fullTypeName, string assemblyPath = "")

        {

            Type type = assemblyPath == "" ? Type.GetType(fullTypeName)

                                           : Assembly.LoadFile(assemblyPath).GetType(fullTypeName);

            if (type == null)

            {

                FileInfo exeFile = new FileInfo(Assembly.GetExecutingAssembly().Location);

                FileInfo[] files = exeFile.Directory.GetFiles("*.dll");

                foreach (FileInfo fi in files)

                {

                    type = GetType(fi.FullName, fullTypeName);

                    if (type != null)

                    {

                        break;

                    }

                }

            }

            if (type == null)

            {

                return null;

            }

            return Activator.CreateInstance(type);

        }

        private Type GetType(string dllFile, string fullTypeName)

        {

            Type type = Assembly.LoadFile(dllFile).GetType(fullTypeName);

            return type;

        }

    }

}