• MySecurity(安全类)


     /// <summary>
        /// MySecurity(安全类) 的摘要说明。
        /// </summary>
        public class MySecurity
        {
            /// <summary>
            /// 初始化安全类
            /// </summary>
            public MySecurity()
            {
                ///默认密码
                key = "0123456789";
            }
            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[8];
                sIV = new byte[8];
                for (int i = 0; i < 8; i++)
                    sKey[i] = hb[i];
                for (int i = 8; i < 16; i++)
                    sIV[i - 8] = hb[i];
                des.Key = sKey;
                des.IV = sIV;
                MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, 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, 0, (int)fs.Length);
                fs.Close();
                byte[] keyByteArray = Encoding.Default.GetBytes(keyStr);
                SHA1 ha = new SHA1Managed();
                byte[] hb = ha.ComputeHash(keyByteArray);
                sKey = new byte[8];
                sIV = new byte[8];
                for (int i = 0; i < 8; i++)
                    sKey[i] = hb[i];
                for (int i = 8; i < 16; i++)
                    sIV[i - 8] = hb[i];
                des.Key = sKey;
                des.IV = sIV;
                MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, 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 / 2];
                for (int x = 0; x < inputStr.Length / 2; x++)
                {
                    int i = (Convert.ToInt32(inputStr.Substring(x * 2, 2), 16));
                    inputByteArray[x] = (byte)i;
                }
                byte[] keyByteArray = Encoding.Default.GetBytes(keyStr);
                SHA1 ha = new SHA1Managed();
                byte[] hb = ha.ComputeHash(keyByteArray);
                sKey = new byte[8];
                sIV = new byte[8];
                for (int i = 0; i < 8; i++)
                    sKey[i] = hb[i];
                for (int i = 8; i < 16; i++)
                    sIV[i - 8] = hb[i];
                des.Key = sKey;
                des.IV = sIV;
                MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, 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, 0, (int)fs.Length);
                fs.Close();
                byte[] keyByteArray = Encoding.Default.GetBytes(keyStr);
                SHA1 ha = new SHA1Managed();
                byte[] hb = ha.ComputeHash(keyByteArray);
                sKey = new byte[8];
                sIV = new byte[8];
                for (int i = 0; i < 8; i++)
                    sKey[i] = hb[i];
                for (int i = 8; i < 16; i++)
                    sIV[i - 8] = hb[i];
                des.Key = sKey;
                des.IV = sIV;
                MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, 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','0','1','2','3','4','5','6','7',
                                                '8','9','+','/','='};
                    byte empty = (byte)0;
                    ArrayList byteMessage = new ArrayList(Encoding.Default.GetBytes(text));
                    StringBuilder outmessage;
                    int messageLen = byteMessage.Count;
                    int page = messageLen / 3;
                    int use = 0;
                    if ((use = messageLen % 3) > 0)
                    {
                        for (int i = 0; i < 3 - use; i++)
                            byteMessage.Add(empty);
                        page++;
                    }
                    outmessage = new System.Text.StringBuilder(page * 4);
                    for (int i = 0; i < page; i++)
                    {
                        byte[] instr = new byte[3];
                        instr[0] = (byte)byteMessage[i * 3];
                        instr[1] = (byte)byteMessage[i * 3 + 1];
                        instr[2] = (byte)byteMessage[i * 3 + 2];
                        int[] outstr = new int[4];
                        outstr[0] = instr[0] >> 2;
                        outstr[1] = ((instr[0] & 0x03) << 4) ^ (instr[1] >> 4);
                        if (!instr[1].Equals(empty))
                            outstr[2] = ((instr[1] & 0x0f) << 2) ^ (instr[2] >> 6);
                        else
                            outstr[2] = 64;
                        if (!instr[2].Equals(empty))
                            outstr[3] = (instr[2] & 0x3f);
                        else
                            outstr[3] = 64;
                        outmessage.Append(Base64Code[outstr[0]]);
                        outmessage.Append(Base64Code[outstr[1]]);
                        outmessage.Append(Base64Code[outstr[2]]);
                        outmessage.Append(Base64Code[outstr[3]]);
                    }
                    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 % 4) != 0)
                    {
                        return "包含不正确的BASE64编码";
                    }
                    if (!Regex.IsMatch(text, "^[A-Z0-9/+=]*$", RegexOptions.IgnoreCase))
                    {
                        return "包含不正确的BASE64编码";
                    }
                    string Base64Code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
                    int page = text.Length / 4;
                    ArrayList outMessage = new ArrayList(page * 3);
                    char[] message = text.ToCharArray();
                    for (int i = 0; i < page; i++)
                    {
                        byte[] instr = new byte[4];
                        instr[0] = (byte)Base64Code.IndexOf(message[i * 4]);
                        instr[1] = (byte)Base64Code.IndexOf(message[i * 4 + 1]);
                        instr[2] = (byte)Base64Code.IndexOf(message[i * 4 + 2]);
                        instr[3] = (byte)Base64Code.IndexOf(message[i * 4 + 3]);
                        byte[] outstr = new byte[3];
                        outstr[0] = (byte)((instr[0] << 2) ^ ((instr[1] & 0x30) >> 4));
                        if (instr[2] != 64)
                        {
                            outstr[1] = (byte)((instr[1] << 4) ^ ((instr[2] & 0x3c) >> 2));
                        }
                        else
                        {
                            outstr[2] = 0;
                        }
                        if (instr[3] != 64)
                        {
                            outstr[2] = (byte)((instr[2] << 6) ^ instr[3]);
                        }
                        else
                        {
                            outstr[2] = 0;
                        }
                        outMessage.Add(outstr[0]);
                        if (outstr[1] != 0)
                            outMessage.Add(outstr[1]);
                        if (outstr[2] != 0)
                            outMessage.Add(outstr[2]);
                    }
                    byte[] outbyte = (byte[])outMessage.ToArray(Type.GetType("System.Byte"));
                    return Encoding.Default.GetString(outbyte);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
        }
  • 相关阅读:
    原型链与继承
    js错误处理Try-catch和throw
    函数柯里化
    js函数节流
    事件委托
    innerHTML属性的内存和性能问题
    微信小程序左滑显示按钮demo
    this的作用
    前端工作面试经典问题(超级全)
    HTML5入门指南
  • 原文地址:https://www.cnblogs.com/qc-id-01/p/7891045.html
Copyright © 2020-2023  润新知