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

namespace CSFrameworkV5.Core.Common
{
    /// <summary>
    /// 最全字符串加密/解密/数字签名工具, www.csframework.com C/S框架网特供！
    /// </summary>
    public class CryptoHelper
    {
        ///// <summary>
        ///// MD5加密，不可逆
        ///// </summary>
        ///// <param name="clearText">明文字符串</param>
        ///// <returns></returns>
        //public static string ToMD5(string clearText)
        //{
        //    MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
        //    byte[] encryptedBytes = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(clearText));
        //    StringBuilder sb = new StringBuilder();
        //    for (int i = 0; i < encryptedBytes.Length; i++)
        //    {
        //        sb.AppendFormat("{0:x2}", encryptedBytes[i]);
        //    }
        //    return sb.ToStringEx();
        //}

        /// <summary>
        /// 散列算法加密SHA256位Hash，不可逆
        /// </summary>
        /// <param name="clearText">明文字符串</param>
        /// <returns></returns>
        public static string ToSHA256Hash(string clearText)
        {
            SHA256 shaM = new SHA256Managed();

            var encryptedBytes =
                shaM.ComputeHash(Encoding.UTF8.GetBytes(clearText));
            var sb = new StringBuilder();
            for (var i = 0; i < encryptedBytes.Length; i++)
                sb.AppendFormat("{0:x2}", encryptedBytes[i]);
            return sb.ToStringEx();
        }

        /// <summary>
        /// 散列算法加密SHA512位Hash，不可逆
        /// </summary>
        /// <param name="clearText">明文字符串</param>
        /// <returns></returns>
        public static string ToSHA512Hash(string clearText)
        {
            SHA512 shaM = new SHA512Managed();

            var encryptedBytes =
                shaM.ComputeHash(Encoding.UTF8.GetBytes(clearText));
            var sb = new StringBuilder();
            for (var i = 0; i < encryptedBytes.Length; i++)
                sb.AppendFormat("{0:x2}", encryptedBytes[i]);

            return sb.ToStringEx();
        }

        #region TripleDES

        ///// <summary>
        ///// TripleDES加密
        ///// </summary>
        ///// <param name="clearText">明文字符串</param>
        ///// <param name="key">16位key</param>
        ///// <param name="iv">8位iv</param>
        ///// <returns></returns>
        //public static string TripleDESEncrypt(string clearText, string key, string iv)
        //{
        //    SymmetricAlgorithm provider = SymmetricAlgorithm.Create("TripleDES");
        //    provider.Key = Encoding.UTF8.GetBytes(key);//16位
        //    provider.IV = Encoding.UTF8.GetBytes(iv);//8位
        //    ICryptoTransform encryptor = provider.CreateEncryptor();
        //    return Encrypt(clearText, encryptor);
        //}

        ///// <summary>
        ///// TripleDES解密
        ///// </summary>
        ///// <param name="encryptedText">加密的文本</param>
        ///// <param name="key">16位key</param>
        ///// <param name="iv">8位iv</param>
        ///// <returns></returns>
        //public static string TripleDESDecrypt(string encryptedText, string key, string iv)
        //{
        //    try
        //    {
        //        SymmetricAlgorithm provider = SymmetricAlgorithm.Create("TripleDES");
        //        provider.Key = Encoding.UTF8.GetBytes(key);//16位
        //        provider.IV = Encoding.UTF8.GetBytes(iv);//8位
        //        ICryptoTransform decryptor = provider.CreateDecryptor();
        //        return Decrypt(encryptedText, decryptor);
        //    }
        //    catch
        //    {
        //        return string.Empty;
        //    }
        //}

        #endregion

        #region DES

        /// <summary>
        /// DES加密
        /// </summary>
        /// <param name="clearText">明文字符串</param>
        /// <param name="key">8位key</param>
        /// <param name="iv">8位iv</param>
        /// <returns></returns>
        //public static string DESEncrypt(string clearText, string key, string iv)
        //{
        //    SymmetricAlgorithm provider = SymmetricAlgorithm.Create("DES");
        //    provider.Key = Encoding.UTF8.GetBytes(key);//8位
        //    provider.IV = Encoding.UTF8.GetBytes(iv);//8位
        //    ICryptoTransform encryptor = provider.CreateEncryptor();
        //    return Encrypt(clearText, encryptor);
        //}

        /// <summary>
        /// DES解密
        /// </summary>
        /// <param name="encryptedText">加密的文本</param>
        /// <param name="key">8位key</param>
        /// <param name="iv">8位iv</param>
        /// <returns></returns>
        //public static string DESDecrypt(string encryptedText, string key, string iv)
        //{
        //    SymmetricAlgorithm provider = SymmetricAlgorithm.Create("DES");
        //    provider.Key = Encoding.UTF8.GetBytes(key);//8位
        //    provider.IV = Encoding.UTF8.GetBytes(iv);//8位
        //    ICryptoTransform decryptor = provider.CreateDecryptor();
        //    return Decrypt(encryptedText, decryptor);
        //}

        #endregion


        //// DES,TripleDES通用加密算法
        //private static string Encrypt(string clearText, ICryptoTransform encryptor)
        //{
        //    // 创建明文流
        //    byte[] clearBuffer = Encoding.UTF8.GetBytes(clearText);
        //    MemoryStream clearStream = new MemoryStream(clearBuffer);

        //    // 创建空的密文流
        //    MemoryStream encryptedStream = new MemoryStream();

        //    CryptoStream cryptoStream =
        //        new CryptoStream(encryptedStream, encryptor, CryptoStreamMode.Write);

        //    // 将明文流写入到buffer中
        //    // 将buffer中的数据写入到cryptoStream中
        //    int BufferSize = 1024;
        //    int bytesRead = 0;
        //    byte[] buffer = new byte[BufferSize];
        //    do
        //    {
        //        bytesRead = clearStream.Read(buffer, 0, BufferSize);
        //        cryptoStream.Write(buffer, 0, bytesRead);
        //    } while (bytesRead > 0);

        //    cryptoStream.FlushFinalBlock();

        //    // 获取加密后的文本
        //    buffer = encryptedStream.ToArray();
        //    string encryptedText = Convert.ToBase64String(buffer);
        //    return encryptedText;
        //}

        //// DES,TripleDES通用解密算法
        //private static string Decrypt(string encryptedText, ICryptoTransform decryptor)
        //{
        //    try
        //    {
        //        byte[] encryptedBuffer = Convert.FromBase64String(encryptedText);
        //        Stream encryptedStream = new MemoryStream(encryptedBuffer);

        //        MemoryStream clearStream = new MemoryStream();
        //        CryptoStream cryptoStream =
        //            new CryptoStream(encryptedStream, decryptor, CryptoStreamMode.Read);

        //        int BufferSize = 1024;
        //        int bytesRead = 0;
        //        byte[] buffer = new byte[BufferSize];

        //        do
        //        {
        //            bytesRead = cryptoStream.Read(buffer, 0, BufferSize);
        //            clearStream.Write(buffer, 0, bytesRead);
        //        } while (bytesRead > 0);

        //        buffer = clearStream.GetBuffer();
        //        string clearText =
        //            Encoding.UTF8.GetString(buffer, 0, (int)clearStream.Length);

        //        return clearText;
        //    }
        //    catch
        //    {
        //        return string.Empty;
        //    }
        //}


        #region Rijndael

        /// <summary>    
        /// 获得密钥    
        /// </summary>    
        /// <returns>密钥</returns>    
        private static byte[] GetLegalKey(RijndaelManaged Rijndael, string key)
        {
            var KeyTemp = key;
            Rijndael.GenerateKey();
            var bytTemp = Rijndael.Key;
            var KeyLength = bytTemp.Length;
            if (KeyTemp.Length > KeyLength)
                KeyTemp = KeyTemp.Substring(0, KeyLength);
            else if (KeyTemp.Length < KeyLength)
                KeyTemp = KeyTemp.PadRight(KeyLength, ' ');
            return Encoding.ASCII.GetBytes(KeyTemp);
        }

        /// <summary>    
        /// 获得初始向量IV    
        /// </summary>    
        /// <returns>初试向量IV</returns>    
        private static byte[] GetLegalIV(RijndaelManaged Rijndael, string iv)
        {
            var IVTemp = iv;
            Rijndael.GenerateIV();
            var bytTemp = Rijndael.IV;
            var IVLength = bytTemp.Length;
            if (IVTemp.Length > IVLength)
                IVTemp = IVTemp.Substring(0, IVLength);
            else if (IVTemp.Length < IVLength)
                IVTemp = IVTemp.PadRight(IVLength, ' ');
            return Encoding.ASCII.GetBytes(IVTemp);
        }

        /// <summary>
        /// Rijndael加密
        /// </summary>
        /// <param name="clearText">明文</param>
        /// <param name="key">key:8位</param>
        /// <param name="iv">iv:8位</param>
        /// <returns></returns>
        public static string RijndaelEncrypt(string clearText, string key,
            string iv)
        {
            var Rijndael = new RijndaelManaged();

            var bytIn = Encoding.UTF8.GetBytes(clearText);
            var ms = new MemoryStream();
            Rijndael.Key = GetLegalKey(Rijndael, key);
            Rijndael.IV = GetLegalIV(Rijndael, iv);
            var encrypto = Rijndael.CreateEncryptor();
            var cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
            cs.Write(bytIn, 0, bytIn.Length);
            cs.FlushFinalBlock();
            ms.Close();
            var bytOut = ms.ToArray();
            return Convert.ToBase64String(bytOut);
        }

        /// <summary>
        /// Rijndael解密
        /// </summary>
        /// <param name="encryptedText">加密的文本</param>
        /// <param name="key">key:8位</param>
        /// <param name="iv">iv:8位</param>
        /// <returns></returns>
        public static string RijndaelDecrypt(string encryptedText, string key,
            string iv)
        {
            try
            {
                var Rijndael = new RijndaelManaged();
                var bytIn = Convert.FromBase64String(encryptedText);
                var ms = new MemoryStream(bytIn, 0, bytIn.Length);
                Rijndael.Key = GetLegalKey(Rijndael, key);
                Rijndael.IV = GetLegalIV(Rijndael, iv);
                var encrypto = Rijndael.CreateDecryptor();
                var cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
                var sr = new StreamReader(cs);
                return sr.ReadToEnd();
            }
            catch
            {
                return string.Empty;
            }
        }

        #endregion

        #region RSA

        /// <summary>
        /// 获取秘钥
        /// </summary>
        /// <param name="privateKey">私钥</param>
        /// <param name="publicKey">公钥</param>
        public static void RSAGetKey(out string privateKey,
            out string publicKey)
        {
            //加密解密用到的公钥与私钥 
            var oRSA = new RSACryptoServiceProvider();
            privateKey = oRSA.ToXmlString(true); //私钥 
            publicKey = oRSA.ToXmlString(false); //公钥 
        }

        /// <summary>
        /// RSA加密
        /// </summary>
        /// <param name="clearText">明文</param>
        /// <param name="publicKey">公钥</param>
        /// <returns></returns>
        public static string RSAEncrypt(string clearText, string publicKey)
        {
            var bytes = Encoding.UTF8.GetBytes(clearText); //需要加密的数据 

            //公钥加密 
            var oRSA1 = new RSACryptoServiceProvider();
            oRSA1.FromXmlString(publicKey); //加密要用到公钥所以导入公钥 
            var AOutput =
                oRSA1.Encrypt(bytes, true); //AOutput 加密以后的数据, true:OAEP填充方式
            return Convert.ToBase64String(AOutput);
        }

        /// <summary>
        /// RSA解密
        /// </summary>
        /// <param name="encryptedText">RSA加密文本</param>
        /// <param name="privateKey">私钥</param>
        /// <returns></returns>
        public static string RSADecrypt(string encryptedText, string privateKey)
        {
            try
            {
                var oRSA2 = new RSACryptoServiceProvider();
                oRSA2.FromXmlString(privateKey);
                var AOutput = Convert.FromBase64String(encryptedText);
                var AInput = oRSA2.Decrypt(AOutput, true); //true:OAEP填充方式
                var reslut = Encoding.UTF8.GetString(AInput);
                return reslut;
            }
            catch
            {
                return string.Empty;
            }
        }

        /// <summary>
        /// RSA数字签名
        /// </summary>
        /// <param name="clearText">明文</param>
        /// <param name="privateKey">私钥</param>
        /// <returns></returns>
        public static string RSASign(string clearText, string privateKey)
        {
            var bs = Encoding.UTF8.GetBytes(clearText);

            var oRSA = new RSACryptoServiceProvider();

            //私钥签名 
            oRSA.FromXmlString(privateKey);
            var AOutput = oRSA.SignData(bs, "SHA1");
            return Convert.ToBase64String(AOutput);
        }

        /// <summary>
        /// RSA验证数字签名
        /// </summary>
        /// <param name="clearText">明文</param>
        /// <param name="signEncryptedText">数字签名</param>
        /// <param name="publicKey">公钥</param>
        /// <returns></returns>
        public static bool RSAVerify(string clearText, string signEncryptedText,
            string publicKey)
        {
            var bs1 = Encoding.UTF8.GetBytes(clearText);
            var bs2 = Convert.FromBase64String(signEncryptedText);

            var oRSA = new RSACryptoServiceProvider();

            //公钥验证             
            oRSA.FromXmlString(publicKey);
            var bVerify = oRSA.VerifyData(bs1, "SHA1", bs2);
            return bVerify;
        }

        #endregion

        #region DSA

        /// <summary>
        /// 获取秘钥
        /// </summary>
        /// <param name="privateKey">私钥</param>
        /// <param name="publicKey">公钥</param>
        public static void DSAGetKey(out string privateKey,
            out string publicKey)
        {
            //加密解密用到的公钥与私钥 
            var DSA = new DSACryptoServiceProvider();
            privateKey = DSA.ToXmlString(true); //私钥 
            publicKey = DSA.ToXmlString(false); //公钥 
        }

        /// <summary>
        /// 获取数字签名
        /// </summary>
        /// <param name="clearText">明文</param>
        /// <param name="privateKey">私钥</param>
        /// <returns></returns>
        public static string DSASign(string clearText, string privateKey)
        {
            var bs = Encoding.UTF8.GetBytes(clearText);

            var DSA = new DSACryptoServiceProvider();

            //私钥签名 
            DSA.FromXmlString(privateKey);
            var AOutput = DSA.SignData(bs);
            return Convert.ToBase64String(AOutput);
        }

        /// <summary>
        /// 验证签名
        /// </summary>
        /// <param name="clearText">明文</param>
        /// <param name="signEncryptedText">明文的数字签名</param>
        /// <param name="publicKey">公钥</param>
        /// <returns></returns>
        public static bool DSAVerify(string clearText, string signEncryptedText,
            string publicKey)
        {
            var bs1 = Encoding.UTF8.GetBytes(clearText);
            var bs2 = Convert.FromBase64String(signEncryptedText);

            var DSA = new DSACryptoServiceProvider();

            //公钥验证             
            DSA.FromXmlString(publicKey);
            var bVerify = DSA.VerifyData(bs1, bs2);
            return bVerify;
        }

        #endregion
    }
}