///

/// MySecurity(安全类) 的摘要说明。 ///

public class MySecurity
{
///

/// 初始化安全类 ///

public MySecurity()
{
///默认密码
key = "";
}
private string key; //默认密钥

    private byte\[\] sKey;  
    private byte\[\] sIV;

    #region 加密字符串  
    /// <summary>  
    /// 加密字符串  
    /// </summary>  
    /// <param name="inputStr">输入字符串</param>  
    /// <param name="keyStr">密码，可以为“”</param>  
    /// <returns>输出加密后字符串</returns>  
    static public string SEncryptString(string inputStr, string keyStr)  
    {  
        MySecurity ws = new MySecurity();  
        return ws.EncryptString(inputStr, keyStr);  
    }  
    /// <summary>  
    /// 加密字符串  
    /// </summary>  
    /// <param name="inputStr">输入字符串</param>  
    /// <param name="keyStr">密码，可以为“”</param>  
    /// <returns>输出加密后字符串</returns>  
    public string EncryptString(string inputStr, string keyStr)  
    {  
        DESCryptoServiceProvider des = new DESCryptoServiceProvider();  
        if (keyStr == "")  
            keyStr = key;  
        byte\[\] inputByteArray = Encoding.Default.GetBytes(inputStr);  
        byte\[\] keyByteArray = Encoding.Default.GetBytes(keyStr);  
        SHA1 ha = new SHA1Managed();  
        byte\[\] hb = ha.ComputeHash(keyByteArray);  
        sKey = new byte\[\];  
        sIV = new byte\[\];  
        for (int i = ; i < ; i++)  
            sKey\[i\] = hb\[i\];  
        for (int i = ; i < ; i++)  
            sIV\[i - \] = hb\[i\];  
        des.Key = sKey;  
        des.IV = sIV;  
        MemoryStream ms = new MemoryStream();  
        CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);  
        cs.Write(inputByteArray, , inputByteArray.Length);  
        cs.FlushFinalBlock();  
        StringBuilder ret = new StringBuilder();  
        foreach (byte b in ms.ToArray())  
        {  
            ret.AppendFormat("{0:X2}", b);  
        }  
        cs.Close();  
        ms.Close();  
        return ret.ToString();  
    }  
    #endregion

    #region 加密字符串 密钥为系统默认 0123456789  
    /// <summary>  
    /// 加密字符串 密钥为系统默认  
    /// </summary>  
    /// <param name="inputStr">输入字符串</param>  
    /// <returns>输出加密后字符串</returns>  
    static public string SEncryptString(string inputStr)  
    {  
        MySecurity ws = new MySecurity();  
        return ws.EncryptString(inputStr, "");  
    }  
    #endregion

    #region 加密文件  
    /// <summary>  
    /// 加密文件  
    /// </summary>  
    /// <param name="filePath">输入文件路径</param>  
    /// <param name="savePath">加密后输出文件路径</param>  
    /// <param name="keyStr">密码，可以为“”</param>  
    /// <returns></returns>  
    public bool EncryptFile(string filePath, string savePath, string keyStr)  
    {  
        DESCryptoServiceProvider des = new DESCryptoServiceProvider();  
        if (keyStr == "")  
            keyStr = key;  
        FileStream fs = File.OpenRead(filePath);  
        byte\[\] inputByteArray = new byte\[fs.Length\];  
        fs.Read(inputByteArray, , (int)fs.Length);  
        fs.Close();  
        byte\[\] keyByteArray = Encoding.Default.GetBytes(keyStr);  
        SHA1 ha = new SHA1Managed();  
        byte\[\] hb = ha.ComputeHash(keyByteArray);  
        sKey = new byte\[\];  
        sIV = new byte\[\];  
        for (int i = ; i < ; i++)  
            sKey\[i\] = hb\[i\];  
        for (int i = ; i < ; i++)  
            sIV\[i - \] = hb\[i\];  
        des.Key = sKey;  
        des.IV = sIV;  
        MemoryStream ms = new MemoryStream();  
        CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);  
        cs.Write(inputByteArray, , inputByteArray.Length);  
        cs.FlushFinalBlock();  
        fs = File.OpenWrite(savePath);  
        foreach (byte b in ms.ToArray())  
        {  
            fs.WriteByte(b);  
        }  
        fs.Close();  
        cs.Close();  
        ms.Close();  
        return true;  
    }  
    #endregion

    #region 解密字符串  
    /// <summary>  
    /// 解密字符串  
    /// </summary>  
    /// <param name="inputStr">要解密的字符串</param>  
    /// <param name="keyStr">密钥</param>  
    /// <returns>解密后的结果</returns>  
    static public string SDecryptString(string inputStr, string keyStr)  
    {  
        MySecurity ws = new MySecurity();  
        return ws.DecryptString(inputStr, keyStr);  
    }  
    /// <summary>  
    ///  解密字符串 密钥为系统默认  
    /// </summary>  
    /// <param name="inputStr">要解密的字符串</param>  
    /// <returns>解密后的结果</returns>  
    static public string SDecryptString(string inputStr)  
    {  
        MySecurity ws = new MySecurity();  
        return ws.DecryptString(inputStr, "");  
    }  
    /// <summary>  
    /// 解密字符串  
    /// </summary>  
    /// <param name="inputStr">要解密的字符串</param>  
    /// <param name="keyStr">密钥</param>  
    /// <returns>解密后的结果</returns>  
    public string DecryptString(string inputStr, string keyStr)  
    {  
        DESCryptoServiceProvider des = new DESCryptoServiceProvider();  
        if (keyStr == "")  
            keyStr = key;  
        byte\[\] inputByteArray = new byte\[inputStr.Length / \];  
        for (int x = ; x < inputStr.Length / ; x++)  
        {  
            int i = (Convert.ToInt32(inputStr.Substring(x \* , ), ));  
            inputByteArray\[x\] = (byte)i;  
        }  
        byte\[\] keyByteArray = Encoding.Default.GetBytes(keyStr);  
        SHA1 ha = new SHA1Managed();  
        byte\[\] hb = ha.ComputeHash(keyByteArray);  
        sKey = new byte\[\];  
        sIV = new byte\[\];  
        for (int i = ; i < ; i++)  
            sKey\[i\] = hb\[i\];  
        for (int i = ; i < ; i++)  
            sIV\[i - \] = hb\[i\];  
        des.Key = sKey;  
        des.IV = sIV;  
        MemoryStream ms = new MemoryStream();  
        CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);  
        cs.Write(inputByteArray, , inputByteArray.Length);  
        cs.FlushFinalBlock();  
        StringBuilder ret = new StringBuilder();  
        return System.Text.Encoding.Default.GetString(ms.ToArray());  
    }  
    #endregion

    #region 解密文件  
    /// <summary>  
    /// 解密文件  
    /// </summary>  
    /// <param name="filePath">输入文件路径</param>  
    /// <param name="savePath">解密后输出文件路径</param>  
    /// <param name="keyStr">密码，可以为“”</param>  
    /// <returns></returns>  
    public bool DecryptFile(string filePath, string savePath, string keyStr)  
    {  
        DESCryptoServiceProvider des = new DESCryptoServiceProvider();  
        if (keyStr == "")  
            keyStr = key;  
        FileStream fs = File.OpenRead(filePath);  
        byte\[\] inputByteArray = new byte\[fs.Length\];  
        fs.Read(inputByteArray, , (int)fs.Length);  
        fs.Close();  
        byte\[\] keyByteArray = Encoding.Default.GetBytes(keyStr);  
        SHA1 ha = new SHA1Managed();  
        byte\[\] hb = ha.ComputeHash(keyByteArray);  
        sKey = new byte\[\];  
        sIV = new byte\[\];  
        for (int i = ; i < ; i++)  
            sKey\[i\] = hb\[i\];  
        for (int i = ; i < ; i++)  
            sIV\[i - \] = hb\[i\];  
        des.Key = sKey;  
        des.IV = sIV;  
        MemoryStream ms = new MemoryStream();  
        CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);  
        cs.Write(inputByteArray, , inputByteArray.Length);  
        cs.FlushFinalBlock();  
        fs = File.OpenWrite(savePath);  
        foreach (byte b in ms.ToArray())  
        {  
            fs.WriteByte(b);  
        }  
        fs.Close();  
        cs.Close();  
        ms.Close();  
        return true;  
    }  
    #endregion

    #region MD5加密  
    /// <summary>  
    /// 128位MD5算法加密字符串  
    /// </summary>  
    /// <param name="text">要加密的字符串</param>  
    public static string MD5(string text)  
    {

        //如果字符串为空，则返回  
        if (Tools.IsNullOrEmpty<string>(text))  
        {  
            return "";  
        }  
        //返回MD5值的字符串表示  
        return MD5(text);  
    }

    /// <summary>  
    /// 128位MD5算法加密Byte数组  
    /// </summary>  
    /// <param name="data">要加密的Byte数组</param>  
    public static string MD5(byte\[\] data)  
    {  
        //如果Byte数组为空，则返回  
        if (Tools.IsNullOrEmpty<byte\[\]>(data))  
        {  
            return "";  
        }

        try  
        {  
            //创建MD5密码服务提供程序  
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();

            //计算传入的字节数组的哈希值  
            byte\[\] result = md5.ComputeHash(data);

            //释放资源  
            md5.Clear();

            //返回MD5值的字符串表示  
            return Convert.ToBase64String(result);  
        }  
        catch  
        {

            //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);  
            return "";  
        }  
    }  
    #endregion

    #region Base64加密  
    /// <summary>  
    /// Base64加密  
    /// </summary>  
    /// <param name="text">要加密的字符串</param>  
    /// <returns></returns>  
    public static string EncodeBase64(string text)  
    {  
        //如果字符串为空，则返回  
        if (Tools.IsNullOrEmpty<string>(text))  
        {  
            return "";  
        }

        try  
        {  
            char\[\] Base64Code = new char\[\]{'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T',  
                                        'U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n',  
                                        'o','p','q','r','s','t','u','v','w','x','y','z','','','','','','','','',  
                                        '','','+','/','='};  
            byte empty = (byte);  
            ArrayList byteMessage = new ArrayList(Encoding.Default.GetBytes(text));  
            StringBuilder outmessage;  
            int messageLen = byteMessage.Count;  
            int page = messageLen / ;  
            int use = ;  
            if ((use = messageLen % ) > )  
            {  
                for (int i = ; i <  - use; i++)  
                    byteMessage.Add(empty);  
                page++;  
            }  
            outmessage = new System.Text.StringBuilder(page \* );  
            for (int i = ; i < page; i++)  
            {  
                byte\[\] instr = new byte\[\];  
                instr\[\] = (byte)byteMessage\[i \* \];  
                instr\[\] = (byte)byteMessage\[i \*  + \];  
                instr\[\] = (byte)byteMessage\[i \*  + \];  
                int\[\] outstr = new int\[\];  
                outstr\[\] = instr\[\] >> ;  
                outstr\[\] = ((instr\[\] & 0x03) << ) ^ (instr\[\] >> );  
                if (!instr\[\].Equals(empty))  
                    outstr\[\] = ((instr\[\] & 0x0f) << ) ^ (instr\[\] >> );  
                else  
                    outstr\[\] = ;  
                if (!instr\[\].Equals(empty))  
                    outstr\[\] = (instr\[\] & 0x3f);  
                else  
                    outstr\[\] = ;  
                outmessage.Append(Base64Code\[outstr\[\]\]);  
                outmessage.Append(Base64Code\[outstr\[\]\]);  
                outmessage.Append(Base64Code\[outstr\[\]\]);  
                outmessage.Append(Base64Code\[outstr\[\]\]);  
            }  
            return outmessage.ToString();  
        }  
        catch (Exception ex)  
        {  
            throw ex;  
        }  
    }  
    #endregion

    #region Base64解密  
    /// <summary>  
    /// Base64解密  
    /// </summary>  
    /// <param name="text">要解密的字符串</param>  
    public static string DecodeBase64(string text)  
    {  
        //如果字符串为空，则返回  
        if (Tools.IsNullOrEmpty<string>(text))  
        {  
            return "";  
        }

        //将空格替换为加号  
        text = text.Replace(" ", "+");

        try  
        {  
            if ((text.Length % ) != )  
            {  
                return "包含不正确的BASE64编码";  
            }  
            if (!Regex.IsMatch(text, "^\[A-Z0-9/+=\]\*$", RegexOptions.IgnoreCase))  
            {  
                return "包含不正确的BASE64编码";  
            }  
            string Base64Code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";  
            int page = text.Length / ;  
            ArrayList outMessage = new ArrayList(page \* );  
            char\[\] message = text.ToCharArray();  
            for (int i = ; i < page; i++)  
            {  
                byte\[\] instr = new byte\[\];  
                instr\[\] = (byte)Base64Code.IndexOf(message\[i \* \]);  
                instr\[\] = (byte)Base64Code.IndexOf(message\[i \*  + \]);  
                instr\[\] = (byte)Base64Code.IndexOf(message\[i \*  + \]);  
                instr\[\] = (byte)Base64Code.IndexOf(message\[i \*  + \]);  
                byte\[\] outstr = new byte\[\];  
                outstr\[\] = (byte)((instr\[\] << ) ^ ((instr\[\] & 0x30) >> ));  
                if (instr\[\] != )  
                {  
                    outstr\[\] = (byte)((instr\[\] << ) ^ ((instr\[\] & 0x3c) >> ));  
                }  
                else  
                {  
                    outstr\[\] = ;  
                }  
                if (instr\[\] != )  
                {  
                    outstr\[\] = (byte)((instr\[\] << ) ^ instr\[\]);  
                }  
                else  
                {  
                    outstr\[\] = ;  
                }  
                outMessage.Add(outstr\[\]);  
                if (outstr\[\] != )  
                    outMessage.Add(outstr\[\]);  
                if (outstr\[\] != )  
                    outMessage.Add(outstr\[\]);  
            }  
            byte\[\] outbyte = (byte\[\])outMessage.ToArray(Type.GetType("System.Byte"));  
            return Encoding.Default.GetString(outbyte);  
        }  
        catch (Exception ex)  
        {  
            throw ex;  
        }  
    }  
    #endregion  
}