构建一个.net的干货类库，以便于快速的开发 - 加密

　　在开发程序的时候，加密是一个程序一个必须的功能，基本上任何程序都会用到加密，而不同的加密方式又适应不同需求，有些加密是不可逆的，最常见是用于用户密码的加密，因为很多时候程序里面不该显示出用户的明文密码，有些加密是可逆的，大多数用于一些私密的资料，例如用户的联系方式，私密信息等，这种加密方式能很好的保护用户的资料。加密方式有很多种，网上可以查到的加密方式有很多，但是很多都不全面，本文就在这里列出比较全面的加密方式。

　　

　　1、MD5加密

　　这种加密方式不用我介绍了吧，最常见的，是一种不可逆加密

　　

  /// <summary>
         /// MD5加密（只能转字符串类型）
         /// </summary>
         /// <param name="str"></param>
         /// <returns></returns>
         public static string toMD5(string str)
         {
             string strResult = str;
             if (!string.IsNullOrWhiteSpace(str))
             {
                 string strSource = str.ToString();
                 //new
                 System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();

                 //获取密文字节数组
                 byte[] bytResult = md5.ComputeHash(System.Text.Encoding.Default.GetBytes(strSource));

                 //转换成字符串，并取9到25位
                 strResult = BitConverter.ToString(bytResult, , );
                 //转换成字符串，32位
                 //string strResult = BitConverter.ToString(bytResult);  

                 //BitConverter转换出来的字符串会在每个字符中间产生一个分隔符，需要去除掉
                 strResult = strResult.Replace("-", "");
             }
             return strResult;
         }

　　

　　2、哈希加密

　　（提供参考）

 /// <summary>
         /// 哈希加密（只能转字符串类型）
         /// </summary>
         /// <param name="str"></param>
         /// <returns></returns>
         public static string toHash(string str)
         {
             string strResult = "";
             if (!string.IsNullOrWhiteSpace(str))
             {
                 string strSource = str.ToString();
                 //Create
                 System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create();

                 //注意编码UTF8、UTF7、Unicode等的选择　
                 byte[] bytResult = md5.ComputeHash(System.Text.Encoding.UTF8.GetBytes(strSource));

                 //字节类型的数组转换为字符串
                 for (int i = ; i < bytResult.Length; i++)
                 {
                     //16进制转换
                     strResult = strResult + bytResult[i].ToString("X");
                 }
             }
             return strResult;
         }

　　3、DES加密（解密）

　　这种加密是一种基于密匙的对称加密

  #region DES加密
         //默认密钥向量
         private static byte[] Keys = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
         /// <summary>
         /// DES加密
         /// </summary>
         /// <param name="encryptString">待加密的字符串</param>
         /// <returns>加密成功返回加密后的字符串，失败返回源串</returns>
         public static string toEncryptDES(string encryptString)
         {
             try
             {
                 string encryptKey = ASCIIEncoding.ASCII.GetString(Keys);
                 byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(, ));
                 byte[] rgbIV = Keys;
                 byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
                 DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();
                 MemoryStream mStream = new MemoryStream();
                 CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                 cStream.Write(inputByteArray, , inputByteArray.Length);
                 cStream.FlushFinalBlock();
                 return Convert.ToBase64String(mStream.ToArray());
             }
             catch
             {
                 return encryptString;
             }
         }
         #endregion

         #region DES解密
         /// <summary>
         /// DES解密
         /// </summary>
         /// <param name="decryptString">待解密的字符串</param>
         /// <returns>解密成功返回解密后的字符串，失败返源串</returns>
         public static string toDecryptDES(string decryptString)
         {
             try
             {
                 string decryptKey = ASCIIEncoding.ASCII.GetString(Keys);
                 byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey);
                 byte[] rgbIV = Keys;
                 byte[] inputByteArray = Convert.FromBase64String(decryptString);
                 DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();
                 MemoryStream mStream = new MemoryStream();
                 CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                 cStream.Write(inputByteArray, , inputByteArray.Length);
                 cStream.FlushFinalBlock();
                 return Encoding.UTF8.GetString(mStream.ToArray());
             }
             catch
             {
                 return decryptString;
             }
         }
         #endregion

　　4、RSA加密（解密）

　　RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击。如果有过支付宝开发经验的开发人员对这个一定不陌生。

　　4.1、密匙生成

　　RSA加密方法需要两个文件用来存放公钥和私钥，在程序里建立key文件来存放这两个文件，由于文件是.pem格式的文件目前没有一种好的读取方式，所以先将文件转换成其他格式文件再读取

 /// <summary>
         /// 密匙生成（慎用）
         /// 注意：当使用此方法时会重新生成一次密匙，之前生成的密匙会被覆盖，使用此方法时建议先进行密匙备份
         /// 首次使用此方法加密要在程序上建立\Key\publicKey.xml和\Key\privateKey.xml两个文件
         /// </summary>
         public static void CreateKey()
         {
             using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
             {
                 //pem文件解析，把pem转换成xml文件
                 string fileName = Utiltity.GetRootPath() + @"\Key\publicKey.xml";
                 using (FileStream fsRead = new FileStream(fileName, FileMode.Create))
                 {
                     string publicKey = rsa.ToXmlString(false); // 公钥
                     StreamWriter sw = new StreamWriter(fsRead);
                     fsRead.SetLength();//首先把文件清空了。
                     sw.Write(publicKey);//写你的字符串。
                     sw.Close();
                     string dfileName = System.IO.Path.ChangeExtension(fileName, ".pem");
                     File.Delete(dfileName);
                     File.Move(fileName, dfileName);
                 }

                 //pem文件解析，把pem转换成xml文件
                 fileName = Utiltity.GetRootPath() + @"\Key\privateKey.xml";
                 using (FileStream fsRead = new FileStream(fileName, FileMode.Create))
                 {
                     string privateKey = rsa.ToXmlString(true); // 私钥
                     StreamWriter sw = new StreamWriter(fsRead);
                     fsRead.SetLength();//首先把文件清空了。
                     sw.Write(privateKey);//写你的字符串。
                     sw.Close();
                     string dfileName = System.IO.Path.ChangeExtension(fileName, ".pem");
                     File.Delete(dfileName);
                     File.Move(fileName, dfileName);
                 }
             }
         }

　　4.2加密（解密）

　　解密要基于对称的密匙，如果不是就解密不了

 /// <summary>
         /// RSA加密
         /// </summary>
         /// <param name="content">需加密的字符串</param>
         /// <returns></returns>
         public static string toEncryptRSA(string content)
         {
             RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
             //pem文件解析，把pem转换成xml文件
             string fileName = Tool.GetRootPath() + @"\Key\publicKey.pem";
             string dfileName = System.IO.Path.ChangeExtension(fileName, ".xml");
             File.Move(fileName, dfileName);
             //文件读取
             using (FileStream fsRead = new FileStream(dfileName, FileMode.Open))
             {
                 StreamReader sr = new StreamReader(fsRead);
                 string publickey = sr.ReadLine();//System.Text.Encoding.UTF8.GetString(heByte);
                 rsa.FromXmlString(publickey);
                 byte[] cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(content), false);
                 content = Convert.ToBase64String(cipherbytes);
             }
             File.Move(dfileName, fileName);
             return content;
         }

 /// <summary>
         /// RSA解密
         /// </summary>
         /// <param name="content">加密的字符串</param>
         /// <returns></returns>
         public static string toDecryptRSA(string content)
         {
             RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
             //pem文件解析，把pem转换成xml文件
             string fileName = Tool.GetRootPath() + @"\Key\privatekey.pem";
             string dfileName = System.IO.Path.ChangeExtension(fileName, ".xml");
             File.Move(fileName, dfileName);
             //文件读取
             using (FileStream fsRead = new FileStream(dfileName, FileMode.Open))
             {
                 //int fsLen = (int)fsRead.Length;
                 //byte[] heByte = new byte[fsLen];
                 StreamReader sr = new StreamReader(fsRead);
                 string privatekey = sr.ReadLine();//System.Text.Encoding.UTF8.GetString(heByte);
                 rsa.FromXmlString(privatekey);
                 byte[] cipherbytes = rsa.Decrypt(Convert.FromBase64String(content), false);
                 content = Encoding.UTF8.GetString(cipherbytes);
             }
             File.Move(dfileName, fileName);
             return content;
         }

　　5、AES对称加密

　　也是一种基于密匙的对称加密

  #region AES对称加密
         /// <summary>
         /// 默认密码钥
         /// </summary>
         private static string EncryptKey = "6FFDC945FA1752467C7F238A3BAB4FEA";

         /// <summary>
         /// 算法初始IV种子
         /// </summary>
         private static string ivString = "1D2CFACB382AE6AD36BD4F4C";

         /// <summary>
         /// AES 加密
         /// </summary>
         /// <param name="encryptString">待加密密文</param>
         /// <param name="key">密钥</param>
         /// <returns></returns>
         public static string AESEncrypt(string encryptString, string key)
         {
             if (string.IsNullOrEmpty(encryptString))
                 return null;
             if (string.IsNullOrEmpty(key)) { throw (new Exception("密钥不得为空")); }
             string m_strEncrypt = "";
             byte[] m_btIV = Convert.FromBase64String(ivString);
             Rijndael m_AESProvider = Rijndael.Create();
             try
             {
                 byte[] m_btEncryptString = Encoding.UTF8.GetBytes(encryptString);
                 MemoryStream m_stream = new MemoryStream();
                 CryptoStream m_csstream = new CryptoStream(m_stream, m_AESProvider.CreateEncryptor(Encoding.UTF8.GetBytes(key), m_btIV), CryptoStreamMode.Write);
                 m_csstream.Write(m_btEncryptString, , m_btEncryptString.Length); m_csstream.FlushFinalBlock();
                 m_strEncrypt = Convert.ToBase64String(m_stream.ToArray());
                 m_strEncrypt = HttpUtility.UrlEncode(m_strEncrypt, Encoding.UTF8);
                 m_stream.Close(); m_stream.Dispose();
                 m_csstream.Close(); m_csstream.Dispose();
             }
             catch (IOException ex) { throw ex; }
             catch (CryptographicException ex) { throw ex; }
             catch (ArgumentException ex) { throw ex; }
             catch (Exception ex) { throw ex; }
             finally { m_AESProvider.Clear(); }
             return m_strEncrypt;
         }

         /// <summary>
         /// AES 加密
         /// </summary>
         /// <param name="encryptString">待加密密文</param>
         /// <returns></returns>
         public static string AESEncrypt(string encryptString)
         {
             return AESEncrypt(encryptString, EncryptKey);
         }
         #endregion

         #region AES对称解密
         /// <summary>
         /// AES 解密
         /// </summary>
         /// <param name="decryptString">待解密密文</param>
         /// <param name="key">解密密钥</param>
         /// <returns></returns>
         public static string AESDecrypt(string decryptString, string key)
         {
             if (string.IsNullOrEmpty(decryptString))
                 return null;
             if (string.IsNullOrEmpty(key)) { throw (new Exception("密钥不得为空")); }
             string m_strDecrypt = "";
             byte[] m_btIV = Convert.FromBase64String(ivString);
             Rijndael m_AESProvider = Rijndael.Create();
             try
             {
                 if (HttpContext.Current == null)
                     decryptString = HttpUtility.UrlDecode(decryptString, Encoding.UTF8);
                 byte[] m_btDecryptString = Convert.FromBase64String(decryptString);
                 MemoryStream m_stream = new MemoryStream();
                 CryptoStream m_csstream = new CryptoStream(m_stream, m_AESProvider.CreateDecryptor(Encoding.UTF8.GetBytes(key), m_btIV), CryptoStreamMode.Write);
                 m_csstream.Write(m_btDecryptString, , m_btDecryptString.Length); m_csstream.FlushFinalBlock();
                 m_strDecrypt = Encoding.UTF8.GetString(m_stream.ToArray());
                 m_stream.Close(); m_stream.Dispose();
                 m_csstream.Close(); m_csstream.Dispose();
             }
             catch (IOException ex) { throw ex; }
             catch (CryptographicException ex) { throw ex; }
             catch (ArgumentException ex) { throw ex; }
             catch (Exception ex) { throw ex; }
             finally { m_AESProvider.Clear(); }
             return m_strDecrypt;
         }

         /// <summary>
         /// AES 解密
         /// </summary>
         /// <param name="decryptString">待解密密文</param>
         /// <returns></returns>
         public static string AESDecrypt(string decryptString)
         {
             return AESDecrypt(decryptString, EncryptKey);
         }

         /// <summary>
         /// 随机生成密钥
         /// </summary>
         /// <returns></returns>
         public static string GetIv(int n)
         {
             char[] arrChar = new char[] { 'a', 'b', 'd', 'c', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'p', 'r', 'q', 's', 't', 'u', 'v', 'w', 'z', 'y', 'x', '', '', '', '', '', '', '', '', '', '', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Q', 'P', 'R', 'T', 'S', 'V', 'U', 'W', 'X', 'Y', 'Z' };
             StringBuilder iv = new StringBuilder();
             Random rnd = new Random(DateTime.Now.Millisecond);
             for (int i = ; i < n; i++)
             {
                 iv.Append(arrChar[rnd.Next(, arrChar.Length)].ToString());
             }
             return iv.ToString();
         }
         #endregion

　　本文的加密方式均修改于网络文章，出处已无法一一列举请见谅