using System;
using System.Text;
using System.IO;
using System.Security.Cryptography;

namespace DataexchangeServer
{
    /// <summary>
    /// ×Ö·û´®¼ÓÃܽâÃÜÀà
    /// </summary>
    public sealed class StringSecurity
    {
        private StringSecurity() { }

        #region SHA1 ¼ÓÃÜ

        /// <summary>
        /// ʹÓÃSHA1¼ÓÃÜ×Ö·û´®¡£
        /// </summary>
        /// <param name="inputString">ÊäÈë×Ö·û´®¡£</param>
        /// <returns>¼ÓÃܺóµÄ×Ö·û´®¡££¨40¸ö×Ö·û£©</returns>
        public static string StringToSHA1Hash(string inputString)
        {
            SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
            byte[] encryptedBytes = sha1.ComputeHash(Encoding.ASCII.GetBytes(inputString));
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < encryptedBytes.Length; i++)
            {
                sb.AppendFormat("{0:x2}", encryptedBytes[i]);
            }
            return sb.ToString();
        }

        #endregion

        #region DES ¼ÓÃÜ/½âÃÜ

        private static byte[] key = ASCIIEncoding.ASCII.GetBytes("uiertysd");
        private static byte[] iv = ASCIIEncoding.ASCII.GetBytes("99008855");

        /// <summary>
        /// DES¼ÓÃÜ¡£
        /// </summary>
        /// <param name="inputString">ÊäÈë×Ö·û´®¡£</param>
        /// <returns>¼ÓÃܺóµÄ×Ö·û´®¡£</returns>
        public static string DESEncrypt(string inputString)
        {
            MemoryStream ms = null;
            CryptoStream cs = null;
            StreamWriter sw = null;

            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            try
            {
                ms = new MemoryStream();
                cs = new CryptoStream(ms, des.CreateEncryptor(key, iv), CryptoStreamMode.Write);
                sw = new StreamWriter(cs);
                sw.Write(inputString);
                sw.Flush();
                cs.FlushFinalBlock();
                return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
            }
            finally
            {
                if (sw != null) sw.Close();
                if (cs != null) cs.Close();
                if (ms != null) ms.Close();
            }
        }

        /// <summary>
        /// DES½âÃÜ¡£
        /// </summary>
        /// <param name="inputString">ÊäÈë×Ö·û´®¡£</param>
        /// <returns>½âÃܺóµÄ×Ö·û´®¡£</returns>
        public static string DESDecrypt(string inputString)
        {
            MemoryStream ms = null;
            CryptoStream cs = null;
            StreamReader sr = null;

            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            try
            {
                ms = new MemoryStream(Convert.FromBase64String(inputString));
                cs = new CryptoStream(ms, des.CreateDecryptor(key, iv), CryptoStreamMode.Read);
                sr = new StreamReader(cs);
                return sr.ReadToEnd();
            }
            finally
            {
                if (sr != null) sr.Close();
                if (cs != null) cs.Close();
                if (ms != null) ms.Close();
            }
        }

        #endregion
    }

    /// <summary>
    /// °²È«º¯Êý¸¨ÖúÀà¡£
    /// </summary>
    public class SecurityHelper 
    {

        #region ¶ÔÍ⹫²¼µÄ¼ÓÃÜÂëËã·¨

        /// <summary>
        /// AES¼ÓÃÜÂëµÄKey
        /// </summary>
        private static readonly string EncryptKey = "1234567891234569123456789123";

        /// <summary>
        /// ¼ÓÃÜ
        /// </summary>
        /// <param name="strPassword">ÐèÒª¼ÓÃܵÄ×Ö·û´®¡£</param>
        /// <returns>·µ»Ø¼ÓÃܺóµÄ×Ö·û´®£¬Èç¹û¼ÓÃÜÂëʧ°Ü·µ»Ø¿Õ¡£</returns>
        public static string Encrypt(string strPassword)
        {
            string Password = AESEncrypt(strPassword, EncryptKey);
            return strPassword == Password ? strPassword : Password;
        }

        /// <summary>
        /// ½âÃÜ
        /// </summary>
        /// <param name="strPassword">¼ÓÃÜÂë×Ö·û´®</param>
        /// <returns>·µ»Ø½âÃܺóµÄ×Ö·û´®£¬Èç¹û½âÃÜÂëʧ°Ü·µ»Ø¿Õ¡£</returns>
        public static string Decrypt(string strPassword)
        {
            string Password = AESDecrypt(strPassword, EncryptKey);
            return strPassword == Password ? strPassword : Password;
        }

        #endregion

        //ĬÈÏDESÃÜÔ¿ÏòÁ¿
        //private static byte[] DES_IV = {0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF};
        //ĬÈÏAESÃÜÔ¿ÏòÁ¿
        private static byte[] AES_IV =
            {
                0x41, 0x72, 0x65, 0x79, 0x6F, 0x75, 0x6D, 0x79, 0x53, 0x6E, 0x6F, 0x77, 0x6D,
                0x61, 0x6E, 0x3F
            };

        //private const string RSASign_HashAlgorithmName = "MD5";
        //private const string RSAEncryptXml_KeyName = "key";

        #region Hashcode

        /// <summary>
        /// MD5º¯Êý¡£
        /// </summary>
        /// <param name="str">ԭʼ×Ö·û´®¡£</param>
        /// <returns>MD5½á¹û¡£</returns>
        public static string MD5(string str)
        {
            byte[] b = Encoding.UTF8.GetBytes(str);
            byte[] hash = MD5(b);

            string ret = "";
            for (int i = 0; i < hash.Length; i++)
                ret += hash[i].ToString("x").PadLeft(2, '0');
            return ret;
        }

        /// <summary>
        /// MD5º¯Êý¡£
        /// </summary>
        /// <param name="data">ԭʼÊý¾ÝÁ÷¡£</param>
        /// <returns>MD5½á¹û¡£</returns>
        public static byte[] MD5(byte[] data)
        {
            return new MD5CryptoServiceProvider().ComputeHash(data);
        }

        /// <summary>
        /// SHA256º¯Êý¡£
        /// </summary>
        /// /// <param name="str">ԭʼ×Ö·û´®¡£</param>
        /// <returns>SHA256½á¹û¡£</returns>
        public static string SHA256(string str)
        {
            byte[] SHA256Data = Encoding.UTF8.GetBytes(str);
            return Convert.ToBase64String(SHA256(SHA256Data)); //·µ»Ø³¤¶ÈΪ44×Ö½ÚµÄ×Ö·û´®
        }

        /// <summary>
        /// SHA256º¯Êý¡£
        /// </summary>
        /// /// <param name="data">ԭʼÊý¾ÝÁ÷¡£</param>
        /// <returns>SHA256½á¹û¡£</returns>
        public static byte[] SHA256(byte[] data)
        {
            SHA256Managed Sha256 = new SHA256Managed();
            return Sha256.ComputeHash(data);
        }

        #endregion

        #region AES¶Ô³Æ¼ÓÃܽâÃÜ

        /// <summary>
        /// AES¼ÓÃÜ¡£
        /// </summary>
        /// <param name="encryptString">´ý¼ÓÃܵÄ×Ö·û´®¡£</param>
        /// <param name="encryptKey">¼ÓÃÜÃÜÔ¿,ÒªÇóΪ32λ¡£</param>
        /// <returns>¼ÓÃܳɹ¦·µ»Ø¼ÓÃܺóµÄ×Ö·û´®,ʧ°Ü·µ»ØÔ´´®¡£</returns>
        private static string AESEncrypt(string encryptString, string encryptKey)
        {
            try
            {
                byte[] inputData = Encoding.UTF8.GetBytes(encryptString);
                return Convert.ToBase64String(AESEncrypt(inputData, encryptKey));
            }
            catch
            {
                return encryptString;
            }
        }

        /// <summary>
        /// AES¼ÓÃÜ¡£
        /// </summary>
        /// <param name="data">´ý¼ÓÃܵÄÊý¾Ý¡£</param>
        /// <param name="encryptKey">¼ÓÃÜÃÜÔ¿,ÒªÇóΪ32λ¡£</param>
        /// <returns>¼ÓÃܳɹ¦·µ»Ø¼ÓÃܺóµÄÊý¾Ý,ʧ°Ü·µ»Ø¿Õ×Ö·û´®¡£</returns>
        private static byte[] AESEncrypt(byte[] data, string encryptKey)
        {
            try
            {
                encryptKey = StringHelper.GetSubString(encryptKey, 32, "");
                encryptKey = encryptKey.PadRight(32, ' ');

                RijndaelManaged rijndaelProvider = new RijndaelManaged();
                rijndaelProvider.Key = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 32));
                rijndaelProvider.IV = AES_IV;
                ICryptoTransform rijndaelEncrypt = rijndaelProvider.CreateEncryptor();

                byte[] inputData = data;
                byte[] encryptedData = rijndaelEncrypt.TransformFinalBlock(inputData, 0, inputData.Length);

                return encryptedData;
            }
            catch (Exception e)
            {
                //Instance.WriteLog(e.Message, false);
                return data;
            }
        }

        /// <summary>
        /// AES½âÃÜ¡£
        /// </summary>
        /// <param name="decryptString">´ý½âÃܵÄ×Ö·û´®¡£</param>
        /// <param name="decryptKey">½âÃÜÃÜÔ¿,ÒªÇóΪ32λ,ºÍ¼ÓÃÜÃÜÔ¿Ïàͬ¡£</param>
        /// <returns>½âÃܳɹ¦·µ»Ø½âÃܺóµÄ×Ö·û´®,ʧ°Ü·µ»Ø¿Õ×Ö·û´®¡£</returns>
        private static string AESDecrypt(string decryptString, string decryptKey)
        {
            try
            {
                byte[] inputData = Convert.FromBase64String(decryptString);
                return Encoding.UTF8.GetString(AESDecrypt(inputData, decryptKey));
            }
            catch
            {
                return decryptString;
            }

        }

        /// <summary>
        /// AES½âÃÜ¡£
        /// </summary>
        /// <param name="data">´ý½âÃܵÄÊý¾Ý¡£</param>
        /// <param name="decryptKey">½âÃÜÃÜÔ¿,ÒªÇóΪ32λ,ºÍ¼ÓÃÜÃÜÔ¿Ïàͬ¡£</param>
        /// <returns>½âÃܳɹ¦·µ»Ø½âÃܺóµÄÊý¾ÝÁ÷,ʧ°Ü·µ»ØÔ´Êý¾Ý¡£</returns>
        private static byte[] AESDecrypt(byte[] data, string decryptKey)
        {
            try
            {
                decryptKey = StringHelper.GetSubString(decryptKey, 32, "");
                decryptKey = decryptKey.PadRight(32, ' ');

                RijndaelManaged rijndaelProvider = new RijndaelManaged();
                rijndaelProvider.Key = Encoding.UTF8.GetBytes(decryptKey);
                rijndaelProvider.IV = AES_IV;
                ICryptoTransform rijndaelDecrypt = rijndaelProvider.CreateDecryptor();

                byte[] inputData = data;
                byte[] decryptedData = rijndaelDecrypt.TransformFinalBlock(inputData, 0, inputData.Length);

                return decryptedData;
            }
            catch
            {
                return data;
            }

        }


        #endregion


    }
}