C# 加密解密类

一. MD5
  1 防止看到明文 数据库密码，加盐(原密码+固定字符串，然后再MD5/双MD5)
  2 防篡改
  3 急速秒传(第一次上传文件，保存md5摘要，第二次上传检查md5摘要)
  4文件下载(防篡改，官方发布的时候给一个md5摘要，安装的时候首先检查下摘要)
  5 svn TFS git VSS(本地保存文件的md5摘要，任何修改都会影响md5)

 public class MD5Encrypt
     {
         #region MD5
         /// <summary>
         /// MD5加密,和动网上的16/32位MD5加密结果相同,
         /// 使用的UTF8编码
         /// </summary>
         /// <param name="source">待加密字串</param>
         /// <param name="length">16或32值之一,其它则采用.net默认MD5加密算法</param>
         /// <returns>加密后的字串</returns>
         public static string Encrypt(string source, int length = )//默认参数
         {
             if (string.IsNullOrEmpty(source)) return string.Empty;
             HashAlgorithm provider = CryptoConfig.CreateFromName("MD5") as HashAlgorithm;
             byte[] bytes = Encoding.UTF8.GetBytes(source);//这里需要区别编码的
             byte[] hashValue = provider.ComputeHash(bytes);
             StringBuilder sb = new StringBuilder();
             switch (length)
             {
                 case ://16位密文是32位密文的9到24位字符
                     for (int i = ; i < ; i++)
                     {
                         sb.Append(hashValue[i].ToString("x2"));
                     }
                     break;
                 case :
                     for (int i = ; i < ; i++)
                     {
                         sb.Append(hashValue[i].ToString("x2"));
                     }
                     break;
                 default:
                     for (int i = ; i < hashValue.Length; i++)
                     {
                         sb.Append(hashValue[i].ToString("x2"));
                     }
                     break;
             }
             return sb.ToString();
         }
         #endregion MD5

         #region MD5摘要
         /// <summary>
         /// 获取文件的MD5摘要
         /// </summary>
         /// <param name="fileName"></param>
         /// <returns></returns>
         public static string AbstractFile(string fileName)
         {
             using (FileStream file = new FileStream(fileName, FileMode.Open))
             {
                 return AbstractFile(file);
             }
         }

         /// <summary>
         /// 根据stream获取文件摘要
         /// </summary>
         /// <param name="stream"></param>
         /// <returns></returns>
         public static string AbstractFile(Stream stream)
         {
             MD5 md5 = new MD5CryptoServiceProvider();
             byte[] retVal = md5.ComputeHash(stream);

             StringBuilder sb = new StringBuilder();
             for (int i = ; i < retVal.Length; i++)
             {
                 sb.Append(retVal[i].ToString("x2"));
             }
             return sb.ToString();
         }
         #endregion
     }

　　二 . DES可逆对称加密

  /// <summary>
     /// DES AES Blowfish
     ///  对称加密算法的优点是速度快，
     ///  缺点是密钥管理不方便，要求共享密钥。
     /// 可逆对称加密  密钥长度8
     /// </summary>
     public class DesEncrypt
     {
         private static byte[] _rgbKey = ASCIIEncoding.ASCII.GetBytes("key"));
         private static byte[] _rgbIV = ASCIIEncoding.ASCII.GetBytes("value");

         /// <summary>
         /// DES 加密
         /// </summary>
         /// <param name="text">需要加密的值</param>
         /// <returns>加密后的结果</returns>
         public static string Encrypt(string text)
         {
             DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
             using (MemoryStream memStream = new MemoryStream())
             {
                 CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateEncryptor(_rgbKey, _rgbIV), CryptoStreamMode.Write);
                 StreamWriter sWriter = new StreamWriter(crypStream);
                 sWriter.Write(text);
                 sWriter.Flush();
                 crypStream.FlushFinalBlock();
                 memStream.Flush();
                 return Convert.ToBase64String(memStream.GetBuffer(), , (int)memStream.Length);
             }
         }

         /// <summary>
         /// DES解密
         /// </summary>
         /// <param name="encryptText"></param>
         /// <returns>解密后的结果</returns>
         public static string Decrypt(string encryptText)
         {
             DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
             byte[] buffer = Convert.FromBase64String(encryptText);

             using (MemoryStream memStream = new MemoryStream())
             {
                 CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateDecryptor(_rgbKey, _rgbIV), CryptoStreamMode.Write);
                 crypStream.Write(buffer, , buffer.Length);
                 crypStream.FlushFinalBlock();
                 return ASCIIEncoding.UTF8.GetString(memStream.ToArray());
             }
         }
     }

　　三 RSA可逆非对称加密

 /// <summary>
     /// RSA ECC
     /// 可逆非对称加密
     /// 非对称加密算法的优点是密钥管理很方便，缺点是速度慢。
     /// </summary>
     public class RsaEncrypt
     {
         /// <summary>
         /// 获取加密/解密对
         /// 给你一个，是无法推算出另外一个的
         ///
         /// Encrypt   Decrypt
         /// </summary>
         /// <returns>Encrypt   Decrypt</returns>
         public static KeyValuePair<string, string> GetKeyPair()
         {
             RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
             string publicKey = RSA.ToXmlString(false);
             string privateKey = RSA.ToXmlString(true);
             return new KeyValuePair<string, string>(publicKey, privateKey);
         }

         /// <summary>
         /// 加密：内容+加密key
         /// </summary>
         /// <param name="content"></param>
         /// <param name="encryptKey">加密key</param>
         /// <returns></returns>
         public static string Encrypt(string content, string encryptKey)
         {
             RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
             rsa.FromXmlString(encryptKey);
             UnicodeEncoding ByteConverter = new UnicodeEncoding();
             byte[] DataToEncrypt = ByteConverter.GetBytes(content);
             byte[] resultBytes = rsa.Encrypt(DataToEncrypt, false);
             return Convert.ToBase64String(resultBytes);
         }

         /// <summary>
         /// 解密  内容+解密key
         /// </summary>
         /// <param name="content"></param>
         /// <param name="decryptKey">解密key</param>
         /// <returns></returns>
         public static string Decrypt(string content, string decryptKey)
         {
             byte[] dataToDecrypt = Convert.FromBase64String(content);
             RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
             RSA.FromXmlString(decryptKey);
             byte[] resultBytes = RSA.Decrypt(dataToDecrypt, false);
             UnicodeEncoding ByteConverter = new UnicodeEncoding();
             return ByteConverter.GetString(resultBytes);
         }

         /// <summary>
         /// 可以合并在一起的，，每次产生一组新的密钥
         /// </summary>
         /// <param name="content"></param>
         /// <param name="encryptKey">加密key</param>
         /// <param name="decryptKey">解密key</param>
         /// <returns>加密后结果</returns>
         private static string Encrypt(string content, out string publicKey, out string privateKey)
         {
             RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider();
             publicKey = rsaProvider.ToXmlString(false);
             privateKey = rsaProvider.ToXmlString(true);

             UnicodeEncoding ByteConverter = new UnicodeEncoding();
             byte[] DataToEncrypt = ByteConverter.GetBytes(content);
             byte[] resultBytes = rsaProvider.Encrypt(DataToEncrypt, false);
             return Convert.ToBase64String(resultBytes);
         }