C#常用加密解密

记录一下使用的加密解密方法:

 public static class Encryptor
 {

     # region Aes加密 解密-ECB模式
     /// <summary>
     /// Aes加密-ECB模式
     /// </summary>
     /// <param name="encryString">待加密字符</param>
     /// <param name="secretKey">密钥</param>
     public static string EncryptionECB(string encryString, string secretKey = "E0AA021E21DDDBD6D8CECEC71E9CF564")
     {
         //加密后的字节数组
         byte[] encryByte;

         using (Aes aes = Aes.Create())
         {
             //密钥
             aes.Key = Encoding.UTF8.GetBytes(secretKey);
             //加密模式
             aes.Mode = CipherMode.ECB;
             //填充模式
             aes.Padding = PaddingMode.PKCS7;

             //加密器
             ICryptoTransform encryptor = aes.CreateEncryptor();

             //创建内存流
             using (MemoryStream memoryStream = new MemoryStream())
             {
                 //创建加密流（存储在内存流中）
                 using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                 {
                     //将待加密字符写入加密流进行加密
                     using (StreamWriter streamWriter = new StreamWriter(cryptoStream))
                     {
                         streamWriter.Write(encryString);
                     }
                 }
                 encryByte = memoryStream.ToArray();
             }
         }

         // 编码为Base64字符串
         string base64String = Convert.ToBase64String(encryByte);
         return base64String;
     }
     /// <summary>
     /// Aes解密-ECB模式
     /// </summary>
     /// <param name="decryString">待解密字符</param>
     /// <param name="secretKey">密钥</param>
     public static string DecryptionECB(string decryString, string secretKey = "E0AA021E21DDDBD6D8CECEC71E9CF564")
     {
         string str = string.Empty;

         using (Aes aes = Aes.Create())
         {
             //密钥
             aes.Key = Encoding.UTF8.GetBytes(secretKey);
             //加密模式
             aes.Mode = CipherMode.ECB;
             //填充模式
             aes.Padding = PaddingMode.PKCS7;

             //解密器
             ICryptoTransform decryptor = aes.CreateDecryptor();

             //密文
             byte[] encryByte = Convert.FromBase64String(decryString);

             //创建内存流
             using (MemoryStream memoryStream = new MemoryStream(encryByte))
             {
                 //创建解密流
                 using (CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                 {
                     using (StreamReader streamReader = new StreamReader(cryptoStream))
                     {
                         str = streamReader.ReadToEnd();
                     }
                 }
             }
         }
         return str;
     }

     #endregion

     #region RSA 加密解密  
     #region RSA 的密钥产生  
     /// <summary>  
     /// RSA产生密钥  
     /// </summary>  
     /// <param name="xmlKeys">私钥</param>  
     /// <param name="xmlPublicKey">公钥</param>  
     public static void RSAKey(out string xmlKeys, out string xmlPublicKey)
     {
         try
         {
             System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
             xmlKeys = rsa.ToXmlString(true);
             xmlPublicKey = rsa.ToXmlString(false);
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     #endregion

     #region RSA加密函数  
     //##############################################################################   
     //RSA 方式加密   
     //KEY必须是XML的形式,返回的是字符串   
     //该加密方式有长度限制的！  
     //##############################################################################   

     /// <summary>  
     /// RSA的加密函数  
     /// </summary>  
     /// <param name="xmlPublicKey">公钥</param>  
     /// <param name="encryptString">待加密的字符串</param>  
     /// <returns></returns>  
     public static string RSAEncrypt(string xmlPublicKey, string encryptString)
     {
         try
         {
             byte[] PlainTextBArray;
             byte[] CypherTextBArray;
             string Result;
             System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
             rsa.FromXmlString(xmlPublicKey);
             PlainTextBArray = (new UnicodeEncoding()).GetBytes(encryptString);
             CypherTextBArray = rsa.Encrypt(PlainTextBArray, false);
             Result = Convert.ToBase64String(CypherTextBArray);
             return Result;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     /// <summary>  
     /// RSA的加密函数   
     /// </summary>  
     /// <param name="xmlPublicKey">公钥</param>  
     /// <param name="EncryptString">待加密的字节数组</param>  
     /// <returns></returns>  
     public static string RSAEncrypt(string xmlPublicKey, byte[] EncryptString)
     {
         try
         {
             byte[] CypherTextBArray;
             string Result;
             System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
             rsa.FromXmlString(xmlPublicKey);
             CypherTextBArray = rsa.Encrypt(EncryptString, false);
             Result = Convert.ToBase64String(CypherTextBArray);
             return Result;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     #endregion

     #region RSA的解密函数          
     /// <summary>  
     /// RSA的解密函数  
     /// </summary>  
     /// <param name="xmlPrivateKey">私钥</param>  
     /// <param name="decryptString">待解密的字符串</param>  
     /// <returns></returns>  
     public static string RSADecrypt(string xmlPrivateKey, string decryptString)
     {
         try
         {
             byte[] PlainTextBArray;
             byte[] DypherTextBArray;
             string Result;
             System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
             rsa.FromXmlString(xmlPrivateKey);
             PlainTextBArray = Convert.FromBase64String(decryptString);
             DypherTextBArray = rsa.Decrypt(PlainTextBArray, false);
             Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
             return Result;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     /// <summary>  
     /// RSA的解密函数   
     /// </summary>  
     /// <param name="xmlPrivateKey">私钥</param>  
     /// <param name="DecryptString">待解密的字节数组</param>  
     /// <returns></returns>  
     public static string RSADecrypt(string xmlPrivateKey, byte[] DecryptString)
     {
         try
         {
             byte[] DypherTextBArray;
             string Result;
             System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
             rsa.FromXmlString(xmlPrivateKey);
             DypherTextBArray = rsa.Decrypt(DecryptString, false);
             Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
             return Result;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     #endregion
     #endregion

     #region RSA数字签名  
     #region 获取Hash描述表          
     /// <summary>  
     /// 获取Hash描述表  
     /// </summary>  
     /// <param name="strSource">待签名的字符串</param>  
     /// <param name="HashData">Hash描述</param>  
     /// <returns></returns>  
     public static bool GetHash(string strSource, ref byte[] HashData)
     {
         try
         {
             byte[] Buffer;
             System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
             Buffer = System.Text.Encoding.GetEncoding("GB2312").GetBytes(strSource);
             HashData = MD5.ComputeHash(Buffer);
             return true;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }

     /// <summary>  
     /// 获取Hash描述表  
     /// </summary>  
     /// <param name="strSource">待签名的字符串</param>  
     /// <param name="strHashData">Hash描述</param>  
     /// <returns></returns>  
     public static bool GetHash(string strSource, ref string strHashData)
     {
         try
         {
             //从字符串中取得Hash描述   
             byte[] Buffer;
             byte[] HashData;
             System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
             Buffer = System.Text.Encoding.GetEncoding("GB2312").GetBytes(strSource);
             HashData = MD5.ComputeHash(Buffer);
             strHashData = Convert.ToBase64String(HashData);
             return true;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }

     /// <summary>  
     /// 获取Hash描述表  
     /// </summary>  
     /// <param name="objFile">待签名的文件</param>  
     /// <param name="HashData">Hash描述</param>  
     /// <returns></returns>  
     public static bool GetHash(System.IO.FileStream objFile, ref byte[] HashData)
     {
         try
         {
             //从文件中取得Hash描述   
             System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
             HashData = MD5.ComputeHash(objFile);
             objFile.Close();
             return true;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }

     /// <summary>  
     /// 获取Hash描述表  
     /// </summary>  
     /// <param name="objFile">待签名的文件</param>  
     /// <param name="strHashData">Hash描述</param>  
     /// <returns></returns>  
     public static bool GetHash(System.IO.FileStream objFile, ref string strHashData)
     {
         try
         {
             //从文件中取得Hash描述   
             byte[] HashData;
             System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
             HashData = MD5.ComputeHash(objFile);
             objFile.Close();
             strHashData = Convert.ToBase64String(HashData);
             return true;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     #endregion

     #region RSA签名  
     /// <summary>  
     /// RSA签名  
     /// </summary>  
     /// <param name="strKeyPrivate">私钥</param>  
     /// <param name="HashbyteSignature">待签名Hash描述</param>  
     /// <param name="EncryptedSignatureData">签名后的结果</param>  
     /// <returns></returns>  
     public static bool SignatureFormatter(string strKeyPrivate, byte[] HashbyteSignature, ref byte[] EncryptedSignatureData)
     {
         try
         {
             System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

             RSA.FromXmlString(strKeyPrivate);
             System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter

 (RSA);
             //设置签名的算法为MD5   
             RSAFormatter.SetHashAlgorithm("MD5");
             //执行签名   
             EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);
             return true;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }

     /// <summary>  
     /// RSA签名  
     /// </summary>  
     /// <param name="strKeyPrivate">私钥</param>  
     /// <param name="HashbyteSignature">待签名Hash描述</param>  
     /// <param name="m_strEncryptedSignatureData">签名后的结果</param>  
     /// <returns></returns>  
     public static bool SignatureFormatter(string strKeyPrivate, byte[] HashbyteSignature, ref string strEncryptedSignatureData)
     {
         try
         {
             byte[] EncryptedSignatureData;
             System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
             RSA.FromXmlString(strKeyPrivate);
             System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter

 (RSA);
             //设置签名的算法为MD5   
             RSAFormatter.SetHashAlgorithm("MD5");
             //执行签名   
             EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);
             strEncryptedSignatureData = Convert.ToBase64String(EncryptedSignatureData);
             return true;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }

     /// <summary>  
     /// RSA签名  
     /// </summary>  
     /// <param name="strKeyPrivate">私钥</param>  
     /// <param name="strHashbyteSignature">待签名Hash描述</param>  
     /// <param name="EncryptedSignatureData">签名后的结果</param>  
     /// <returns></returns>  
     public static bool SignatureFormatter(string strKeyPrivate, string strHashbyteSignature, ref byte[] EncryptedSignatureData)
     {
         try
         {
             byte[] HashbyteSignature;

             HashbyteSignature = Convert.FromBase64String(strHashbyteSignature);
             System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();


             RSA.FromXmlString(strKeyPrivate);
             System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter

 (RSA);
             //设置签名的算法为MD5   
             RSAFormatter.SetHashAlgorithm("MD5");
             //执行签名   
             EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);

             return true;
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }

     /// <summary>  
     /// RSA签名  
     /// </summary>  
     /// <param name="strKeyPrivate">私钥</param>  
     /// <param name="strHashbyteSignature">待签名Hash描述</param>  
     /// <param name="strEncryptedSignatureData">签名后的结果</param>  
     /// <returns></returns>  
     public static bool SignatureFormatter(string strKeyPrivate, string strHashbyteSignature, ref string strEncryptedSignatureData)
     {
         try
         {
             byte[] HashbyteSignature;
             byte[] EncryptedSignatureData;
             HashbyteSignature = Convert.FromBase64String(strHashbyteSignature);
             System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
             RSA.FromXmlString(strKeyPrivate);
             System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter(RSA);
             //设置签名的算法为MD5   
             RSAFormatter.SetHashAlgorithm("MD5");
             //执行签名   
             EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);
             strEncryptedSignatureData = Convert.ToBase64String(EncryptedSignatureData);
             return true;
         }
         catch (Exception ex)
         {
             return false;
         }
     }
     #endregion

     #region RSA 签名验证  
     /// <summary>  
     /// RSA签名验证  
     /// </summary>  
     /// <param name="strKeyPublic">公钥</param>  
     /// <param name="HashbyteDeformatter">Hash描述</param>  
     /// <param name="DeformatterData">签名后的结果</param>  
     /// <returns></returns>  
     public static bool SignatureDeformatter(string strKeyPublic, byte[] HashbyteDeformatter, byte[] DeformatterData)
     {
         try
         {
             System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
             RSA.FromXmlString(strKeyPublic);
             System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new

 System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
             //指定解密的时候HASH算法为MD5   
             RSADeformatter.SetHashAlgorithm("MD5");
             if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     /// <summary>  
     /// RSA签名验证  
     /// </summary>  
     /// <param name="strKeyPublic">公钥</param>  
     /// <param name="strHashbyteDeformatter">Hash描述</param>  
     /// <param name="DeformatterData">签名后的结果</param>  
     /// <returns></returns>  
     public static bool SignatureDeformatter(string strKeyPublic, string strHashbyteDeformatter, byte[] DeformatterData)
     {
         try
         {
             byte[] HashbyteDeformatter;
             HashbyteDeformatter = Convert.FromBase64String(strHashbyteDeformatter);
             System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
             RSA.FromXmlString(strKeyPublic);
             System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new

 System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
             //指定解密的时候HASH算法为MD5   
             RSADeformatter.SetHashAlgorithm("MD5");
             if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     /// <summary>  
     /// RSA签名验证  
     /// </summary>  
     /// <param name="strKeyPublic">公钥</param>  
     /// <param name="HashbyteDeformatter">Hash描述</param>  
     /// <param name="strDeformatterData">签名后的结果</param>  
     /// <returns></returns>  
     public static bool SignatureDeformatter(string strKeyPublic, byte[] HashbyteDeformatter, string strDeformatterData)
     {
         try
         {
             byte[] DeformatterData;
             System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
             RSA.FromXmlString(strKeyPublic);
             System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new

 System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
             //指定解密的时候HASH算法为MD5   
             RSADeformatter.SetHashAlgorithm("MD5");
             DeformatterData = Convert.FromBase64String(strDeformatterData);
             if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
     /// <summary>  
     /// RSA签名验证  
     /// </summary>  
     /// <param name="strKeyPublic">公钥</param>  
     /// <param name="strHashbyteDeformatter">Hash描述</param>  
     /// <param name="strDeformatterData">签名后的结果</param>  
     /// <returns></returns>  
     public static bool SignatureDeformatter(string strKeyPublic, string strHashbyteDeformatter, string strDeformatterData)
     {
         try
         {
             byte[] DeformatterData;
             byte[] HashbyteDeformatter;
             HashbyteDeformatter = Convert.FromBase64String(strHashbyteDeformatter);
             System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();
             RSA.FromXmlString(strKeyPublic);
             System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
             //指定解密的时候HASH算法为MD5   
             RSADeformatter.SetHashAlgorithm("MD5");
             DeformatterData = Convert.FromBase64String(strDeformatterData);
             if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }
         catch (Exception ex)
         {
             return false;
         }
     }
     #endregion
     #endregion
 }