对称加密

    #region --System.Security.Cryptography--
    //mscorlib --> System.Security.Cryptography
    //散列算法
    //HashAlgorithm
    //      |-------MD5
    //      |       |----------MD5CryptoServiceProvider
    //      |
    //      |-------SHA1
    //      |       |----------SHA1Managed(SHA1CryptoServiceProvider)
    //      |
    //      |-------SHA256
    //      |       |----------SHA256Managed
    //      |
    //      |-------SHA384
    //      |       |----------SHA384Managed
    //      |
    //      |-------SHA512
    //      |       |----------SHA512Managed
    //      |
    //      |-------RIPEMD160
    //      |       |----------RIPEMD160Managed
    //      |
    //      |-------KeyedHashAlgorithm
    //              |----------HMAC
    //              |           |----------------HMACMD5
    //              |           |----------------HMACSHA1
    //              |           |----------------HMACSHA256
    //              |           |----------------HMACSHA384
    //              |           |----------------HMACSHA512
    //              |           |----------------HMACRIPEMD160
    //              |
    //              |----------MACTripleDES

    //对称加密算法
    //SymmetricAlgorithm
    //      |-------DES
    //      |       |-----------DESCryptoServiceProvider
    //      |
    //      |-------Rijndael
    //      |       |-----------RijndaelManaged
    //      |
    //      |-------RC2
    //      |       |-----------RC2CryptoServiceProvider
    //      |
    //      |-------TripleDES
    //              |-----------TripleDESCryptoServiceProvider

    //非对称加密算法
    //AsymmetricAlgorithm
    //      |-------RSA
    //      |       |-----------RSACryptoServiceProvider
    //      |
    //      |-------DSA
    //              |-----------DSACryptoServiceProvider

    //AsymmetricKeyExchangeFormatter
    //      |-------RSAOAEPKeyExchangeFormatter
    //      |-------RSAPKCSIKeyExchangeFormatter

    //AsymmetricKeyExchangeDeformatter
    //      |-------RSAOAEPKeyExchangeDeformatter
    //      |-------RSAPKCSIKeyExchangeDeformatter

    //AsymmetricSignatureFormatter
    //      |-------RSAPKCSISignatureFormatter
    //      |-------DSASignatureFormatter

    ////AsymmetricSignatureDeformatter
    //      |-------RSAPKCSISignatureDeformatter
    //      |-------DSASignatureDeformatter
    #endregion

    /// <summary>
    /// 加 解 密的对象
    /// </summary>
    public class EncryptModel
    {
        /// <summary>
        /// 暂时只根据key，iv进行设置
        /// </summary>
        /// <param name="key"></param>
        /// <param name="iv"></param>
        public EncryptModel(string key, string iv)
        {
            this._key = key;
            this._iv = iv;
        }

        /// <summary>
        /// 密钥
        /// </summary>
        private string _key = string.Empty;
        /// <summary>
        /// 向量
        /// </summary>
        private string _iv = string.Empty;
        /// <summary>
        /// 密钥长度
        /// </summary>
        private int _keySize = 8;
        /// <summary>
        /// 获取或设置加密操作的块大小（以位为单位）
        /// </summary>
        private int _blockSize = 8;

        /// <summary>
        /// 获取或设置加密操作的反馈大小（以位为单位）。
        /// </summary>
        private int _feedbackSize = 0;

        /// <summary>
        /// 获取或设置对称算法的运算模式。CipherMode.CBC
        /// </summary>
        private CipherMode _cryptMode;
        /// <summary>
        /// 获取或设置对称算法中使用的填充模式。PaddingMode.ANSIX923
        /// </summary>
        private PaddingMode _cryptPadding;
        /// <summary>
        /// 加密密钥(8個英文字)
        /// </summary>
        public string Key
        {
            get { return _key; }
            set { _key = value.Length == 8 ? value : "AndyCode"; }//暂时定义为8
        }
        /// <summary>
        /// 初始化向量(8個英文字)
        /// </summary>
        public string Iv
        {
            get { return _iv; }
            set { _iv = value.Length == 8 ? value : "HeXiaoEr"; }//暂时定义为8
        }
        /// <summary>
        /// 密钥长度
        /// </summary>
        public int KeyLength
        {
            get { return _keySize; }
            set { _keySize = value; }
        }
        /// <summary>
        /// 获取或设置加密操作的块大小（以位为单位）
        /// </summary>
        public int BlockSize
        {
            get { return _blockSize; }
            set { _blockSize = value; }
        }
        /// <summary>
        /// 获取或设置加密操作的反馈大小（以位为单位）。
        /// </summary>
        public int FeedbackSize
        {
            get { return _feedbackSize; }
            set { _feedbackSize = value; }
        }
        /// <summary>
        /// 获取或设置对称算法的运算模式。CipherMode.CBC
        /// </summary>
        public CipherMode CryptMode
        {
            get { return _cryptMode; }
            set { _cryptMode = value; }
        }
        /// <summary>
        /// 获取或设置对称算法中使用的填充模式。PaddingMode.ANSIX923
        /// </summary>
        public PaddingMode CryptPadding
        {
            get { return _cryptPadding; }
            set { _cryptPadding = value; }
        }
    }



    /// <summary>
    /// 加密解密算法基类
    /// </summary>
    public abstract class EncryptDecrypt
    {
        public abstract string Encrypt(string encryptStr, EncryptModel encryptModel);
        public abstract string Decrypt(string decryptStr, EncryptModel decryptModel);
    }

#region -- 对称加密 --

    //在对称加密算法中，数据发信方将明文（原始数据）和加密密钥一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。
    //收信方收到密文后，若想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。

    //BlockSize         获取或设置加密操作的块大小（以位为单位）。
    //FeedbackSize      获取或设置加密操作的反馈大小（以位为单位）。
    //IV                获取或设置对称算法的初始化向量 (IV)。
    //Key               已重写。获取或设置数据加密标准 (DES) 算法的机密密钥。
    //KeySize           获取或设置对称算法使用的机密密钥的大小（以位为单位）。
    //Mode              获取或设置对称算法的运算模式。
    //Padding           获取或设置对称算法中使用的填充模式。

    //LegalBlockSizes   获取对称算法支持的块大小。
    //LegalKeySizes     获取对称算法支持的密钥大小。

    //Clear()           释放由 SymmetricAlgorithm 占用的所有资源。
    //CreateDecryptor() 已重载。已重写。创建对称数据加密标准 (DES) 解密器对象。
    //CreateEncryptor() 已重载。已重写。创建对称数据加密标准 (DES) 加密器对象。
    //GenerateIV()      已重写。生成用于该算法的随机初始化向量（IV）。
    //GenerateKey()     已重写。生成用于该算法的随机 Key。
    //ValidKeySize()    确定指定的密钥大小对当前算法是否有效。
    /// <summary>
    /// Des加密解密 8字节的key，初始向量IV也是8字节。
    /// </summary>
    public class DesEncryptDecrypt : EncryptDecrypt
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="encryptStr"></param>
        /// <param name="encryptModel"></param>
        /// <returns></returns>
        public override string Encrypt(string encryptStr, EncryptModel encryptModel)
        {
            string temp = string.Empty;
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())//DES算法的加密类
            {
                //将字符串转换为byte
                byte[] inputByteArray = Encoding.Default.GetBytes(encryptStr);
                //设定对称算法的加密密钥(长度为64位,也就是8个字节)
                des.Key = ASCIIEncoding.ASCII.GetBytes(encryptModel.Key);
                //设定对称算法的初始化向量(长度为64位,也就是8个字节)
                des.IV = ASCIIEncoding.ASCII.GetBytes(encryptModel.Iv);

                using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
                {
                    using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(inputByteArray, 0, inputByteArray.Length);
                        cs.FlushFinalBlock();
                    }
                    temp = Convert.ToBase64String(ms.ToArray());
                }
            }
            return temp;
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="decryptStr"></param>
        /// <param name="decryptModel"></param>
        /// <returns></returns>
        public override string Decrypt(string decryptStr, EncryptModel decryptModel)
        {
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())//DES算法的加密类
            {
                byte[] inputByteArray = new byte[decryptStr.Length / 2];
                //反转
                for (int x = 0; x < decryptStr.Length / 2; x++)
                {
                    int i = (Convert.ToInt32(decryptStr.Substring(x * 2, 2), 16));
                    inputByteArray[x] = (byte)i;
                }
                //解密密钥必须是加密时候的密钥
                des.Key = ASCIIEncoding.ASCII.GetBytes(decryptModel.Key);
                //解密向量必须是加密时候的向量
                des.IV = ASCIIEncoding.ASCII.GetBytes(decryptModel.Iv);
                using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
                {
                    using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read))
                    {
                        try
                        {
                            cs.Write(inputByteArray, 0, inputByteArray.Length);
                            cs.FlushFinalBlock();
                            return System.Text.Encoding.Default.GetString(ms.ToArray());
                        }
                        catch
                        {
                            return "N/A";
                        }
                    }
                }
            }
        }
    }
    /// <summary>
    /// RC2加密解密 any个字节key，初始向量IV也是8字节。
    /// </summary>
    public class Rc2EncryptDecrypt : EncryptDecrypt
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="encryptStr"></param>
        /// <param name="encryptModel"></param>
        /// <returns></returns>
        public override string Encrypt(string encryptStr, EncryptModel encryptModel)
        {
            string temp = string.Empty;
            using (RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider())//RC2算法的加密类
            {
                //将字符串转换为byte
                byte[] inputByteArray = Encoding.Default.GetBytes(encryptStr);
                //设定对称算法的加密密钥
                rc2.Key = ASCIIEncoding.ASCII.GetBytes(encryptModel.Key);
                //设定对称算法的初始化向量(长度为64位,也就是8个字节)
                rc2.IV = ASCIIEncoding.ASCII.GetBytes(encryptModel.Iv);
                using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
                {
                    using (CryptoStream cs = new CryptoStream(ms, rc2.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(inputByteArray, 0, inputByteArray.Length);
                        cs.FlushFinalBlock();
                    }
                    temp = Convert.ToBase64String(ms.ToArray());
                }
            }
            return temp;
        }
        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="decryptStr"></param>
        /// <param name="decryptModel"></param>
        /// <returns></returns>
        public override string Decrypt(string decryptStr, EncryptModel decryptModel)
        {
            using (RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider())//RC2算法的加密类
            {
                //将字符串转换为byte
                byte[] inputByteArray = Encoding.Default.GetBytes(decryptStr);
                //设定对称算法的加密密钥 密钥必须为5-16位
                rc2.Key = ASCIIEncoding.ASCII.GetBytes(decryptModel.Key);
                //设定对称算法的初始化向量(长度为64位,也就是8个字节)
                rc2.IV = ASCIIEncoding.ASCII.GetBytes(decryptModel.Iv);
                using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
                {
                    using (CryptoStream cs = new CryptoStream(ms, rc2.CreateDecryptor(), CryptoStreamMode.Read))
                    {
                        try
                        {
                            cs.Write(inputByteArray, 0, inputByteArray.Length);
                            cs.FlushFinalBlock();
                            return Encoding.Default.GetString(ms.ToArray());
                        }
                        catch
                        {
                            return "N/A";
                        }
                    }
                }
            }
        }
    }
    /// <summary>
    /// Rijndael加密解密 16，24或42字节的key，初始向量IV也是8字节。 AES
    /// </summary>
    public class RijndaelEncryptDecrypt : EncryptDecrypt
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="encryptStr"></param>
        /// <param name="encryptModel"></param>
        /// <returns></returns>
        public override string Encrypt(string encryptStr, EncryptModel encryptModel)
        {
            string temp = string.Empty;
            using (RijndaelManaged rijndael = new RijndaelManaged())//RC2算法的加密类
            {
                //将字符串转换为byte
                byte[] inputByteArray = Encoding.Default.GetBytes(encryptStr);
                //设定对称算法的加密密钥
                rijndael.Key = ASCIIEncoding.ASCII.GetBytes(encryptModel.Key);
                //设定对称算法的初始化向量(长度为64位,也就是8个字节)
                rijndael.IV = ASCIIEncoding.ASCII.GetBytes(encryptModel.Iv);
                using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
                {
                    using (CryptoStream cs = new CryptoStream(ms, rijndael.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(inputByteArray, 0, inputByteArray.Length);
                        cs.FlushFinalBlock();
                    }
                    temp = Convert.ToBase64String(ms.ToArray());
                }
            }
            return temp;
        }
        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="decryptStr"></param>
        /// <param name="decryptModel"></param>
        /// <returns></returns>
        public override string Decrypt(string decryptStr, EncryptModel decryptModel)
        {
            using (RijndaelManaged rijndael = new RijndaelManaged())//Rijndael算法的加密类
            {
                //将字符串转换为byte
                byte[] inputByteArray = Encoding.Default.GetBytes(decryptStr);
                //设定对称算法的加密密钥 密钥必须为5-16位
                rijndael.Key = ASCIIEncoding.ASCII.GetBytes(decryptModel.Key);
                //设定对称算法的初始化向量(长度为64位,也就是8个字节)
                rijndael.IV = ASCIIEncoding.ASCII.GetBytes(decryptModel.Iv);
                using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
                {
                    using (CryptoStream cs = new CryptoStream(ms, rijndael.CreateDecryptor(), CryptoStreamMode.Read))
                    {
                        try
                        {
                            cs.Write(inputByteArray, 0, inputByteArray.Length);
                            cs.FlushFinalBlock();
                            return Encoding.Default.GetString(ms.ToArray());
                        }
                        catch
                        {
                            return "N/A";
                        }
                    }
                }
            }
        }
    }
    /// <summary>
    /// TripleDes加密解密 16或24字节的key，初始向量IV也是8字节。
    /// </summary>
    public class TripleDesEncryptDecrypt : EncryptDecrypt
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="encryptStr"></param>
        /// <param name="encryptModel"></param>
        /// <returns></returns>
        public override string Encrypt(string encryptStr, EncryptModel encryptModel)
        {
            string temp = string.Empty;
            using (TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider())//RC2算法的加密类
            {
                //将字符串转换为byte
                byte[] inputByteArray = Encoding.Default.GetBytes(encryptStr);
                //设定对称算法的加密密钥
                tripleDES.Key = ASCIIEncoding.ASCII.GetBytes(encryptModel.Key);
                //设定对称算法的初始化向量(长度为64位,也就是8个字节)
                tripleDES.IV = ASCIIEncoding.ASCII.GetBytes(encryptModel.Iv);
                using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
                {
                    using (CryptoStream cs = new CryptoStream(ms, tripleDES.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(inputByteArray, 0, inputByteArray.Length);
                        cs.FlushFinalBlock();
                    }
                    temp = Convert.ToBase64String(ms.ToArray());
                }
            }
            return temp;
        }
        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="decryptStr"></param>
        /// <param name="decryptModel"></param>
        /// <returns></returns>
        public override string Decrypt(string decryptStr, EncryptModel decryptModel)
        {
            using (TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider())//TripleDES算法的加密类
            {
                //将字符串转换为byte
                byte[] inputByteArray = Encoding.Default.GetBytes(decryptStr);
                //设定对称算法的加密密钥 密钥必须为5-16位
                tripleDES.Key = ASCIIEncoding.ASCII.GetBytes(decryptModel.Key);
                //设定对称算法的初始化向量(长度为64位,也就是8个字节)
                tripleDES.IV = ASCIIEncoding.ASCII.GetBytes(decryptModel.Iv);
                using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
                {
                    using (CryptoStream cs = new CryptoStream(ms, tripleDES.CreateDecryptor(), CryptoStreamMode.Read))
                    {
                        try
                        {
                            cs.Write(inputByteArray, 0, inputByteArray.Length);
                            cs.FlushFinalBlock();
                            return Encoding.Default.GetString(ms.ToArray());
                        }
                        catch
                        {
                            return "N/A";
                        }
                    }
                }
            }
        }
    }
    #endregion