using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
namespace ETD.Data
{

    /// <summary>
    /// 数据加密类
    /// </summary>
    public sealed class Security
    {
        private static byte[] Keys = new byte[] { 0x41, 0x72, 0x65, 0x79, 0x6f, 0x75, 0x6d, 0x79, 0x53, 110, 0x6f, 0x77, 0x6d, 0x61, 110, 0x3f };
        /// <summary>
        /// 初始化向量变量
        /// </summary>
        private string m_IV = string.Empty;
        /// <summary>
        /// 密钥变量
        /// </summary>
        private string m_Key = string.Empty;
        /// <summary>
        /// 3DES加密对象的实例
        /// </summary>
        private SymmetricAlgorithm mCSP = new TripleDESCryptoServiceProvider();

        /// <summary>
        /// 构造器
        /// </summary>
        public Security()
        {
            this.GetKey();
            this.GetIV();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="decryptString"></param>
        /// <param name="decryptKey"></param>
        /// <returns></returns>
        public static string Decode(string decryptString, string decryptKey)
        {
            try
            {
                decryptKey = Text.CutString(decryptKey, 0x20, "");
                decryptKey = decryptKey.PadRight(0x20, ' ');
                RijndaelManaged rijndaelProvider = new RijndaelManaged();
                rijndaelProvider.Key = Encoding.UTF8.GetBytes(decryptKey);
                rijndaelProvider.IV = Keys;
                ICryptoTransform rijndaelDecrypt = rijndaelProvider.CreateDecryptor();
                byte[] inputData = Convert.FromBase64String(decryptString);
                byte[] decryptedData = rijndaelDecrypt.TransformFinalBlock(inputData, 0, inputData.Length);
                return Encoding.UTF8.GetString(decryptedData);
            }
            catch
            {
                return "";
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="encryptString"></param>
        /// <param name="encryptKey"></param>
        /// <returns></returns>
        public static string Encode(string encryptString, string encryptKey)
        {
            encryptKey = Text.CutString(encryptKey, 0x20, "");
            encryptKey = encryptKey.PadRight(0x20, ' ');
            RijndaelManaged rijndaelProvider = new RijndaelManaged();
            rijndaelProvider.Key = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 0x20));
            rijndaelProvider.IV = Keys;
            ICryptoTransform rijndaelEncrypt = rijndaelProvider.CreateEncryptor();
            byte[] inputData = Encoding.UTF8.GetBytes(encryptString);
            return Convert.ToBase64String(rijndaelEncrypt.TransformFinalBlock(inputData, 0, inputData.Length));
        }

        /// <summary>
        /// 3DES+异或加密数据
        /// </summary>
        /// <param name="EncryString">需要解码密的数据</param>
        /// <param name="Key">密钥</param>
        /// <returns>加密后的数据</returns>
        public string Encrypt(string EncryString, string Key)
        {
            string str = this.Encrypt3DESString(EncryString);
            return this.EncryptKey(str, Key, true);
        }

        /// <summary>
        /// 3DES加密数据
        /// </summary>
        /// <param name="EncryptString">需要加密的数据</param>
        /// <returns>加密后的数据</returns>
        public string Encrypt3DESString(string EncryptString)
        {
            StringBuilder p_strEncStr = new StringBuilder();
            p_strEncStr.Append(EncryptString);
            ICryptoTransform ct = this.mCSP.CreateEncryptor(this.mCSP.Key, this.mCSP.IV);
            byte[] byt = Encoding.UTF8.GetBytes(p_strEncStr.ToString());
            MemoryStream ms = new MemoryStream();
            CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
            cs.Write(byt, 0, byt.Length);
            cs.FlushFinalBlock();
            cs.Close();
            return this.GetOut3DESLicense(Convert.ToBase64String(ms.ToArray()));
        }

        /// <summary>
        /// 异或字符串加密方法
        /// </summary>
        /// <param name="str">需要加密的字符串</param>
        /// <param name="key">加密密钥,为空时使用默认密钥</param>
        /// <param name="bl">true:使用随机加密因子;false:不使用随机加密因子</param>
        /// <returns>返回加密后的字符串</returns>
        public string EncryptKey(string str, string key, bool bl)
        {
            int offset;
            int keyLen = key.Length;
            if (keyLen == 0)
            {
                key = "zllscs";
            }
            int keyPos = 0;
            int SrcPos = 0;
            int SrcAsc = 0;
            Random rd = new Random();
            if (bl)
            {
                offset = rd.Next(0, 0x100);
            }
            else
            {
                offset = 14;
            }
            string dest = string.Format("{0:X2}", offset);
            char[] chr = str.ToCharArray();
            char[] keychr = key.ToCharArray();
            byte[] strBt = Encoding.ASCII.GetBytes(chr);
            byte[] keyBt = Encoding.ASCII.GetBytes(keychr);
            for (SrcPos = 0; SrcPos < str.Length; SrcPos++)
            {
                SrcAsc = (strBt[SrcPos] + offset) % 0xff;
                if (keyPos < keyLen)
                {
                    SrcAsc ^= keyBt[keyPos];
                    keyPos++;
                }
                else
                {
                    keyPos = 0;
                    SrcAsc ^= keyBt[keyPos];
                }
                dest = dest + string.Format("{0:X2}", SrcAsc);
                offset = SrcAsc;
            }
            return dest;
        }

        /// <summary>
        /// 输出3DES加密的数据,并将3DES的初始化向量和关键字赋给对应属性
        /// </summary>
        /// <param name="EnyData">加密的数据</param>
        /// <returns>组合好的数据</returns>
        private string Get3DESLicenseKey(string EnyData)
        {
            string p_strKey = EnyData.Substring(20, 0x20);
            this.mCSP.Key = Convert.FromBase64String(p_strKey);
            EnyData = EnyData.Remove(20, 0x20);
            string p_strIV = EnyData.Substring(10, 12);
            this.mCSP.IV = Convert.FromBase64String(p_strIV);
            EnyData = EnyData.Remove(10, 12);
            return EnyData;
        }

        /// <summary>
        /// 获得3DES加密的初始化向量
        /// </summary>
        private void GetIV()
        {
            this.mCSP.GenerateIV();
            this.IV = Convert.ToBase64String(this.mCSP.IV);
        }

        /// <summary>
        /// 获得3DES加密的密钥
        /// </summary>
        private void GetKey()
        {
            this.mCSP.GenerateKey();
            this.Key = Convert.ToBase64String(this.mCSP.Key);
        }

        /// <summary>
        /// 3DES组合输出的到文件中的数据
        /// </summary>
        /// <param name="EnyData">加密的数据</param>
        /// <returns>组合好的数据</returns>
        private string GetOut3DESLicense(string EnyData)
        {
            EnyData = EnyData.Insert(10, this.IV);
            EnyData = EnyData.Insert(20, this.Key);
            return EnyData;
        }

        /// <summary>
        /// Md5加密
        /// </summary>
        /// <param name="Code">加密的字符串</param>
        /// <param name="CodeType">编码方式</param>
        /// <returns></returns>
        public static string MD5Encode(string Code, string CodeType)
        {
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            byte[] InBytes = Encoding.GetEncoding(CodeType).GetBytes(Code);
            byte[] OutBytes = md5.ComputeHash(InBytes);
            string OutString = "";
            for (int i = 0; i < OutBytes.Length; i++)
            {
                OutString = OutString + OutBytes[i].ToString("x2");
            }
            return OutString;
        }

        /// <summary>
        /// 3DES+异或解密数据
        /// </summary>
        /// <param name="EncryString">需要解密的数据</param>
        /// <param name="Key">密钥</param>
        /// <returns>加密后的数据</returns>
        public string Uncrypt(string EncryString, string Key)
        {
            string str = this.UncryptKey(EncryString, Key, true);
            return this.Uncrypt3DESString(str);
        }

        /// <summary>
        /// 3DES数据解密
        /// </summary>
        /// <param name="EncryString">需要解密的字符串</param>
        /// <returns>解密后的原始数据</returns>
        public string Uncrypt3DESString(string EncryString)
        {
            EncryString = this.Get3DESLicenseKey(EncryString);
            ICryptoTransform ct = this.mCSP.CreateDecryptor(this.mCSP.Key, this.mCSP.IV);
            byte[] byt = Convert.FromBase64String(EncryString);
            MemoryStream ms = new MemoryStream();
            CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
            cs.Write(byt, 0, byt.Length);
            cs.FlushFinalBlock();
            cs.Close();
            return Encoding.UTF8.GetString(ms.ToArray());
        }

        /// <summary>
        /// 异或字符串加密方法
        /// </summary>
        /// <param name="str">需要加密的字符串</param>
        /// <param name="key">加密密钥,为空时使用默认密钥</param>
        /// <param name="bl">true:使用随机加密因子;false:不使用随机加密因子</param>
        /// <returns>返回加密后的字符串</returns>
        public string UncryptKey(string str, string key, bool bl)
        {
            string row;
            try
            {
                int offset;
                string dest = "";
                int keyLen = key.Length;
                if (keyLen == 0)
                {
                    key = "zllscs";
                }
                int keyPos = 0;
                int SrcPos = 0;
                int SrcAsc = 0;
                int TmpSrcAsc = 0;
                char[] keychr = key.ToCharArray();
                byte[] keyBt = Encoding.ASCII.GetBytes(keychr);
                if (bl)
                {
                    offset = Convert.ToInt32("0x" + str.Substring(0, 2), 0x10);
                }
                else
                {
                    offset = 14;
                }
                for (SrcPos = 2; SrcPos < str.Length; SrcPos += 2)
                {
                    SrcAsc = Convert.ToInt32("0x" + str.Substring(SrcPos, 2), 0x10);
                    if (keyPos < keyLen)
                    {
                        TmpSrcAsc = SrcAsc ^ keyBt[keyPos];
                        keyPos++;
                    }
                    else
                    {
                        keyPos = 0;
                        TmpSrcAsc = SrcAsc ^ keyBt[keyPos];
                    }
                    if (TmpSrcAsc <= offset)
                    {
                        TmpSrcAsc = (0xff + TmpSrcAsc) - offset;
                    }
                    else
                    {
                        TmpSrcAsc -= offset;
                    }
                    dest = dest + Convert.ToChar(TmpSrcAsc);
                    offset = SrcAsc;
                }
                row = dest;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
            return row;
        }

        /// <summary>
        /// 初始化向量字符串形式
        /// </summary>
        private string IV
        {
            get
            {
                return this.m_IV;
            }
            set
            {
                this.m_IV = value;
            }
        }

        /// <summary>
        /// 密钥字符串形式
        /// </summary>
        private string Key
        {
            get
            {
                return this.m_Key;
            }
            set
            {
                this.m_Key = value;
            }
        }
    }
}