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

public class CryptoHelperService
{
    #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)
    {
        string KeyTemp = key;
        Rijndael.GenerateKey();
        byte[] bytTemp = Rijndael.Key;
        int KeyLength = bytTemp.Length;
        if (KeyTemp.Length > KeyLength)
            KeyTemp = KeyTemp.Substring(0, KeyLength);
        else if (KeyTemp.Length < KeyLength)
            KeyTemp = KeyTemp.PadRight(KeyLength, ' ');
        return ASCIIEncoding.ASCII.GetBytes(KeyTemp);
    }
    /// <summary>    
    /// 获得初始向量IV    
    /// </summary>    
    /// <returns>初试向量IV</returns>    
    private static byte[] GetLegalIV(RijndaelManaged Rijndael, string iv)
    {
        string IVTemp = iv;
        Rijndael.GenerateIV();
        byte[] bytTemp = Rijndael.IV;
        int IVLength = bytTemp.Length;
        if (IVTemp.Length > IVLength)
            IVTemp = IVTemp.Substring(0, IVLength);
        else if (IVTemp.Length < IVLength)
            IVTemp = IVTemp.PadRight(IVLength, ' ');
        return ASCIIEncoding.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)
    {
        RijndaelManaged Rijndael = new RijndaelManaged();

        byte[] bytIn = UTF8Encoding.UTF8.GetBytes(clearText);
        MemoryStream ms = new MemoryStream();
        Rijndael.Key = GetLegalKey(Rijndael, key);
        Rijndael.IV = GetLegalIV(Rijndael, iv);
        ICryptoTransform encrypto = Rijndael.CreateEncryptor();
        CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
        cs.Write(bytIn, 0, bytIn.Length);
        cs.FlushFinalBlock();
        ms.Close();
        byte[] 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
        {
            RijndaelManaged Rijndael = new RijndaelManaged();
            byte[] bytIn = Convert.FromBase64String(encryptedText);
            MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);
            Rijndael.Key = GetLegalKey(Rijndael, key);
            Rijndael.IV = GetLegalIV(Rijndael, iv);
            ICryptoTransform encrypto = Rijndael.CreateDecryptor();
            CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
            StreamReader 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)
    {
        //加密解密用到的公钥与私钥 
        RSACryptoServiceProvider 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)
    {
        byte[] bytes = Encoding.UTF8.GetBytes(clearText); //需要加密的数据 

        //公钥加密 
        RSACryptoServiceProvider oRSA1 = new RSACryptoServiceProvider();
        oRSA1.FromXmlString(publicKey); //加密要用到公钥所以导入公钥 
        byte[] 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
        {
            RSACryptoServiceProvider oRSA2 = new RSACryptoServiceProvider();
            oRSA2.FromXmlString(privateKey);
            byte[] AOutput = Convert.FromBase64String(encryptedText);
            byte[] AInput = oRSA2.Decrypt(AOutput, true);//true:OAEP填充方式
            string 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)
    {
        byte[] bs = Encoding.UTF8.GetBytes(clearText);

        RSACryptoServiceProvider oRSA = new RSACryptoServiceProvider();

        //私钥签名 
        oRSA.FromXmlString(privateKey);
        byte[] 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)
    {
        byte[] bs1 = Encoding.UTF8.GetBytes(clearText);
        byte[] bs2 = Convert.FromBase64String(signEncryptedText);

        RSACryptoServiceProvider oRSA = new RSACryptoServiceProvider();

        //公钥验证             
        oRSA.FromXmlString(publicKey);
        bool 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)
    {
        //加密解密用到的公钥与私钥 
        DSACryptoServiceProvider 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)
    {
        byte[] bs = Encoding.UTF8.GetBytes(clearText);

        DSACryptoServiceProvider DSA = new DSACryptoServiceProvider();

        //私钥签名 
        DSA.FromXmlString(privateKey);
        byte[] 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)
    {
        byte[] bs1 = Encoding.UTF8.GetBytes(clearText);
        byte[] bs2 = Convert.FromBase64String(signEncryptedText);

        DSACryptoServiceProvider DSA = new DSACryptoServiceProvider();

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


    #endregion
}