C#常用加密方法、MD5、SHA、HMAC、RSA、Base64等

thetwodan

于 2024-08-27 10:15:10 发布

阅读量271

点赞数 7

分类专栏： C# 文章标签： c# 开发语言密码学 .net

本文链接：https://blog.csdn.net/qq_36246584/article/details/141593927

版权

C# 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

整理了一下C#常用加密方法

MD5加密

        public static string MD532(string data)
        {
            MD5 md = MD5.Create();
            byte[] OutBytes = md.ComputeHash(System.Text.Encoding.UTF8.GetBytes(data));

            string OutString = "";
            for (int i = 0; i < OutBytes.Length; i++)
            {
                OutString += OutBytes[i].ToString("x2");
            }

            return OutString.ToLower();
        }

SHA 加密

sha1、sha256、sha512

  /// <summary>
  /// SHA1 加密
  /// </summary>
  public static string Sha1(this string value)
  {
      if (value == null)
      {
          throw new ArgumentNullException("未将对象引用设置到对象的实例。");
      }

      var encoding = Encoding.UTF8;
      SHA1 sha1 = new SHA1CryptoServiceProvider();
      return HashAlgorithmBase(sha1, value, encoding);
  }

  /// <summary>
  /// SHA256 加密
  /// </summary>
  public static string Sha256(this string filepath)
  {
      if (filepath == null)
      {
          throw new ArgumentNullException("未将对象引用设置到对象的实例。");
      }

      //var encoding = Encoding.UTF8;
      //SHA256 sha256 = new SHA256Managed();
      //return HashAlgorithmBase(sha256, value, encoding);

      Stream stream = File.Open(filepath, FileMode.OpenOrCreate);

      SHA256 sha256 = new SHA256Managed();
      byte[] hashStr = sha256.ComputeHash(stream);
      stream.Close();
      return hashStr.Bytes2Str().TrimStart('0');
  }

  /// <summary>
  /// SHA512 加密
  /// </summary>
  public static string Sha512(this string value)
  {
      if (value == null)
      {
          throw new ArgumentNullException("未将对象引用设置到对象的实例。");
      }
      var encoding = Encoding.UTF8;
      SHA512 sha512 = new SHA512Managed();
      return HashAlgorithmBase(sha512, value, encoding);
  }

HMAC 加密

HmacSha1

 public static string HmacSha1(this string value, string keyVal)
 {
     if (value == null)
     {
         throw new ArgumentNullException("未将对象引用设置到对象的实例。");
     }
     var encoding = Encoding.UTF8;
     byte[] keyStr = encoding.GetBytes(keyVal);
     HMACSHA1 hmacSha1 = new HMACSHA1(keyStr);
     return HashAlgorithmBase(hmacSha1, value, encoding);
 }

HmacSha256

      /// <summary>
      /// HmacSha256 加密
      /// </summary>
      public static string HmacSha256(this string value, string keyVal)
      {
          if (value == null)
          {
              throw new ArgumentNullException("未将对象引用设置到对象的实例。");
          }
          var encoding = Encoding.UTF8;
          byte[] keyStr = encoding.GetBytes(keyVal);
          HMACSHA256 hmacSha256 = new HMACSHA256(keyStr);
          return HashAlgorithmBase(hmacSha256, value, encoding);
      }

HmacSha384

  /// <summary>
  /// HmacSha384 加密
  /// </summary>
  public static string HmacSha384(this string value, string keyVal)
  {
      if (value == null)
      {
          throw new ArgumentNullException("未将对象引用设置到对象的实例。");
      }
      var encoding = Encoding.UTF8;
      byte[] keyStr = encoding.GetBytes(keyVal);
      HMACSHA384 hmacSha384 = new HMACSHA384(keyStr);
      return HashAlgorithmBase(hmacSha384, value, encoding);
  }

HmacSha512

  /// <summary>
  /// HmacSha512 加密
  /// </summary>
  public static string HmacSha512(this string value, string keyVal)
  {
      if (value == null)
      {
          throw new ArgumentNullException("未将对象引用设置到对象的实例。");
      }
      var encoding = Encoding.UTF8;
      byte[] keyStr = encoding.GetBytes(keyVal);
      HMACSHA512 hmacSha512 = new HMACSHA512(keyStr);
      return HashAlgorithmBase(hmacSha512, value, encoding);
  }

HmacMd5

   /// <summary>
   /// HmacMd5 加密
   /// </summary>
   public static string HmacMd5(this string value, string keyVal)
   {
       if (value == null)
       {
           throw new ArgumentNullException("未将对象引用设置到对象的实例。");
       }
       var encoding = Encoding.UTF8;
       byte[] keyStr = encoding.GetBytes(keyVal);
       HMACMD5 hmacMd5 = new HMACMD5(keyStr);
       return HashAlgorithmBase(hmacMd5, value, encoding);
   }

HmacRipeMd160

  /// <summary>
  /// HmacRipeMd160 加密
  /// </summary>
  public static string HmacRipeMd160(this string value, string keyVal)
  {
      if (value == null)
      {
          throw new ArgumentNullException("未将对象引用设置到对象的实例。");
      }
      var encoding = Encoding.UTF8;
      byte[] keyStr = encoding.GetBytes(keyVal);
      HMACRIPEMD160 hmacRipeMd160 = new HMACRIPEMD160(keyStr);
      return HashAlgorithmBase(hmacRipeMd160, value, encoding);
  }

AES 加密解密

  /// <summary>
  ///  AES 加密
  /// </summary>
  /// <param name="str"></param>
  /// <param name="key"></param>
  /// <returns></returns>
  public static string AesEncrypt(string str, string key)
  {
      byte[] keyArray = UTF8Encoding.UTF8.GetBytes(key);
      byte[] ivArray = new byte[16];//UTF8Encoding.UTF8.GetBytes(iv);
      byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(str);
      RijndaelManaged aes = new RijndaelManaged();
      aes.Key = keyArray;
      aes.IV = ivArray;
      aes.Mode = CipherMode.CBC;
      aes.Padding = PaddingMode.ISO10126;
      ICryptoTransform cTransform = aes.CreateEncryptor();
      byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
      return Convert.ToBase64String(resultArray, 0, resultArray.Length);
  }

  /// <summary>
  ///  AES 解密
  /// </summary>
  /// <param name="str"></param>
  /// <param name="key"></param>
  /// <returns></returns>
  public static string AesDecrypt(string str, string key)
  {
      byte[] keyArray = UTF8Encoding.UTF8.GetBytes(key);
      byte[] ivArray = new byte[16];//UTF8Encoding.UTF8.GetBytes(iv);
      byte[] toEncryptArray = Convert.FromBase64String(str);
      RijndaelManaged aes = new RijndaelManaged();
      aes.Key = keyArray;
      aes.IV = ivArray;
      aes.Mode = CipherMode.CBC;
      aes.Padding = PaddingMode.ISO10126;
      ICryptoTransform cTransform = aes.CreateDecryptor();
      byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
      return UTF8Encoding.UTF8.GetString(resultArray);
  }

DES 加密解密

 /// <summary>
 /// DES加密。
 /// </summary>
 /// <param name="pToEncrypt">要加密的字符串。</param>
 /// <param name="sKey">密钥，且必须为8位。</param>
 /// <returns>以Base64格式返回的加密字符串。</returns>
 public static string DES(string pToEncrypt, string sKey)
 {
     using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
     {
         byte[] inputByteArray = Encoding.UTF8.GetBytes(pToEncrypt);
         des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
         des.IV = new byte[8]; //ASCIIEncoding.ASCII.GetBytes(sKey);
         des.Mode = CipherMode.ECB;
         System.IO.MemoryStream ms = new System.IO.MemoryStream();
         using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
         {
             cs.Write(inputByteArray, 0, inputByteArray.Length);
             cs.FlushFinalBlock();
             cs.Close();
         }
         string str = Convert.ToBase64String(ms.ToArray());
         ms.Close();
         return str;
     }
 }

 // <summary>
 // DES解密。
 // </summary>
 // <param name="pToDecrypt">要解密的以Base64</param>
 // <param name="sKey">密钥，且必须为8位。</param>
 // <returns>已解密的字符串。</returns>
 public static string UNDES(string pToDecrypt, string sKey)
 {
     byte[] inputByteArray = Convert.FromBase64String(pToDecrypt);
     using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
     {
         des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
         des.IV = new byte[8];//ASCIIEncoding.ASCII.GetBytes(sKey);
         des.Mode = CipherMode.ECB;
         System.IO.MemoryStream ms = new System.IO.MemoryStream();
         using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
         {
             cs.Write(inputByteArray, 0, inputByteArray.Length);
             cs.FlushFinalBlock();
             cs.Close();
         }
         string str = Encoding.UTF8.GetString(ms.ToArray());
         ms.Close();
         return str;
     }
 }

3DES加密解密


        /// <summary>
        /// 3des ecb模式加密
        /// </summary>
        /// <param name="aStrString">待加密的字符串</param>
        /// <param name="aStrKey">密钥</param>
        /// <param name="iv">加密矢量：只有在CBC解密模式下才适用</param>
        /// <param name="mode">运算模式</param>
        /// <returns>加密后的字符串</returns>
        public static string Encrypt3Des(string aStrString, string aStrKey, CipherMode mode = CipherMode.ECB, string iv = "12345678")
        {
            try
            {
                var des = new TripleDESCryptoServiceProvider
                {
                    Key = Encoding.UTF8.GetBytes(aStrKey),
                    Mode = mode
                };
                if (mode == CipherMode.CBC)
                {
                    des.IV = Encoding.UTF8.GetBytes(iv);
                }
                var desEncrypt = des.CreateEncryptor();
                byte[] buffer = Encoding.UTF8.GetBytes(aStrString);
                return Convert.ToBase64String(desEncrypt.TransformFinalBlock(buffer, 0, buffer.Length));
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }


 /// <summary>
 /// des 解密
 /// </summary>
 /// <param name="aStrString">加密的字符串</param>
 /// <param name="aStrKey">密钥</param>
 /// <param name="iv">解密矢量：只有在CBC解密模式下才适用</param>
 /// <param name="mode">运算模式</param>
 /// <returns>解密的字符串</returns>
 public static string Decrypt3Des(string aStrString, string aStrKey, CipherMode mode = CipherMode.ECB, string iv = "12345678")
 {
     try
     {
         var des = new TripleDESCryptoServiceProvider
         {
             Key = Encoding.UTF8.GetBytes(aStrKey),
             Mode = mode,
             Padding = PaddingMode.PKCS7
         };
         if (mode == CipherMode.CBC)
         {
             des.IV = Encoding.UTF8.GetBytes(iv);
         }
         var desDecrypt = des.CreateDecryptor();
         var result = "";
         byte[] buffer = Convert.FromBase64String(aStrString);
         result = Encoding.UTF8.GetString(desDecrypt.TransformFinalBlock(buffer, 0, buffer.Length));
         return result;
     }
     catch (Exception)
     {
         return string.Empty;
     }
 }

RSA 加密解密

RSA 的密钥产生

  /// <summary>  
  /// RSA产生密钥  
  /// </summary>  
  /// <param name="PriKey">私钥</param>  
  /// <param name="PubKey">公钥</param>  
  public static void RSAKey(out string PubKey, out string PriKey)
  {
      //生成密钥对  
      RsaKeyPairGenerator rsaKeyPairGenerator = new RsaKeyPairGenerator();
      RsaKeyGenerationParameters rsaKeyGenerationParameters = new RsaKeyGenerationParameters(BigInteger.ValueOf(3), new Org.BouncyCastle.Security.SecureRandom(), 1024, 25);
      rsaKeyPairGenerator.Init(rsaKeyGenerationParameters);//初始化参数  
      AsymmetricCipherKeyPair keyPair = rsaKeyPairGenerator.GenerateKeyPair();
      AsymmetricKeyParameter publicKey = keyPair.Public;//公钥  
      AsymmetricKeyParameter privateKey = keyPair.Private;//私钥  

      SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey);
      PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);

      Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();
      byte[] publicInfoByte = asn1ObjectPublic.GetEncoded();
      Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
      byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded();

      PubKey = Convert.ToBase64String(publicInfoByte);
      PriKey = Convert.ToBase64String(privateInfoByte);
  }

RSA的公钥加密函数

 /// <summary>  
 /// RSA的公钥加密函数  
 /// </summary>  
 /// <param name="PublicKey">公钥</param>  
 /// <param name="encryptString">待加密的字符串</param>  
 /// <returns></returns>  
 public static string RSAPub(string encryptString, string PublicKey)
 {
     Asn1Object pubKeyObj = Asn1Object.FromByteArray(Convert.FromBase64String(PublicKey));
     AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(SubjectPublicKeyInfo.GetInstance(pubKeyObj));

     IAsymmetricBlockCipher cipher = new RsaEngine();
     cipher.Init(true, pubKey);//true表示加密  
     //加密  
     byte[] encryptData = cipher.ProcessBlock(Encoding.UTF8.GetBytes(encryptString), 0, Encoding.UTF8.GetBytes(encryptString).Length);
     return Convert.ToBase64String(encryptData);
 }

RSA的私钥加密函数

/// <summary>  
/// RSA的私钥加密函数  
/// </summary>  
/// <param name="PrivateKey">私钥</param>  
/// <param name="encryptString">待加密的字符串</param>  
/// <returns></returns>  
public static string RSAPri(string encryptString, string PrivateKey)
{
    Asn1Object priKeyObj = Asn1Object.FromByteArray(Convert.FromBase64String(PrivateKey));
    AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(PrivateKeyInfo.GetInstance(priKeyObj));

    IAsymmetricBlockCipher cipher = new RsaEngine();
    cipher.Init(true, priKey);//true表示加密  
    //加密  
    byte[] encryptData = cipher.ProcessBlock(Encoding.UTF8.GetBytes(encryptString), 0, Encoding.UTF8.GetBytes(encryptString).Length);
    return Convert.ToBase64String(encryptData);
}

RSA的私钥解密函数

 /// <summary>  
 /// RSA的私钥解密函数  
 /// </summary>  
 /// <param name="PrivateKey">私钥</param>  
 /// <param name="decryptString">待解密的字符串</param>  
 /// <returns></returns>  
 public static string UnRSAPri(string decryptString, string PrivateKey)
 {
     Asn1Object priKeyObj = Asn1Object.FromByteArray(Convert.FromBase64String(PrivateKey));
     AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(PrivateKeyInfo.GetInstance(priKeyObj));

     IAsymmetricBlockCipher cipher = new RsaEngine();
     cipher.Init(false, priKey);//false表示解密  
     byte[] encryptData = Convert.FromBase64String(decryptString);
     return Encoding.UTF8.GetString(cipher.ProcessBlock(encryptData, 0, encryptData.Length));
 }

RSA的公钥解密函数

  /// <summary>  
  /// RSA的公钥解密函数  
  /// </summary>  
  /// <param name="PublicKey">公钥</param>  
  /// <param name="decryptString">待解密的字符串</param>  
  /// <returns></returns>  
  public static string UnRSAPub(string decryptString, string PublicKey)
  {
      Asn1Object pubKeyObj = Asn1Object.FromByteArray(Convert.FromBase64String(PublicKey));
      AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(SubjectPublicKeyInfo.GetInstance(pubKeyObj));

      IAsymmetricBlockCipher cipher = new RsaEngine();
      cipher.Init(false, pubKey);//false表示解密  
      byte[] encryptData = Convert.FromBase64String(decryptString);
      return Encoding.UTF8.GetString(cipher.ProcessBlock(encryptData, 0, encryptData.Length));
  }

RSA数字签名

获取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;
         HashAlgorithm SHA1 = HashAlgorithm.Create("SHA1");
         Buffer = System.Text.Encoding.GetEncoding("GB2312").GetBytes(strSource);
         HashData = SHA1.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;
         HashAlgorithm SHA1 = HashAlgorithm.Create("SHA1");
         Buffer = System.Text.Encoding.GetEncoding("GB2312").GetBytes(strSource);
         HashData = SHA1.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描述   
         HashAlgorithm SHA1 = HashAlgorithm.Create("SHA1");
         HashData = SHA1.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;
         HashAlgorithm SHA1 = HashAlgorithm.Create("SHA1");
         HashData = SHA1.ComputeHash(objFile);
         objFile.Close();
         strHashData = Convert.ToBase64String(HashData);
         return true;
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }

加签

  /// <summary>  
  /// 加签  
  /// </summary>  
  /// <param name="data">数据源</param>  
  /// <param name="privateKey">私钥</param>  
  /// <param name="hashAlgorithm">哈希格式</param>  
  /// <param name="encoding">编码格式</param>  
  /// <returns></returns>  
  public static string RSASign(string data, string privateKey, string hashAlgorithm = "SHA1withRSA", string encoding = "UTF-8")
  {
      RsaKeyParameters privateKeyParam = null;
      try
      {
          privateKeyParam = (RsaKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));
      }
      catch (Exception e)
      {
          string aa = e.Message;
      }
      ISigner signer = SignerUtilities.GetSigner(hashAlgorithm);
      signer.Init(true, privateKeyParam);//参数为true加签，参数为false验签  
      var dataByte = Encoding.GetEncoding(encoding).GetBytes(data);
      signer.BlockUpdate(dataByte, 0, dataByte.Length);
      //return Encoding.GetEncoding(encoding).GetString(signer.GenerateSignature()); //签名结果 非Base64String  
      return Convert.ToBase64String(signer.GenerateSignature());
  }

验签

   /// <summary>  
   /// 验签 
   /// </summary>  
   /// <param name="data">源数据</param>  
   /// <param name="publicKeyJava">公钥</param>  
   /// <param name="signature">base64签名</param>  
   /// <param name="hashAlgorithm">哈希格式</param>  
   /// <param name="encoding">编码格式</param>  
   /// <returns></returns>  
   public static bool RSAVerify(string data, string publicKeyJava, string signature, string hashAlgorithm = "SHA1withRSA", string encoding = "UTF-8")
   {
       RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKeyJava));
       ISigner signer = SignerUtilities.GetSigner(hashAlgorithm);
       signer.Init(false, publicKeyParam);
       byte[] dataByte = Encoding.GetEncoding(encoding).GetBytes(data);
       signer.BlockUpdate(dataByte, 0, dataByte.Length);
       //byte[] signatureByte = Encoding.GetEncoding(encoding).GetBytes(signature);// 非Base64String  
       byte[] signatureByte = Convert.FromBase64String(signature);
       return signer.VerifySignature(signatureByte);
   }

BASE64 加密解密

  /// <summary>
  /// BASE64 加密
  /// </summary>
  /// <param name="value">待加密字段</param>
  /// <returns></returns>
  public static string Base64(this string value)
  {
      var btArray = Encoding.UTF8.GetBytes(value);
      return Convert.ToBase64String(btArray, 0, btArray.Length);
  }

  /// <summary>
  /// BASE64 解密
  /// </summary>
  /// <param name="value">待解密字段</param>
  /// <returns></returns>
  public static string UnBase64(this string value)
  {
      var btArray = Convert.FromBase64String(value);
      return Encoding.UTF8.GetString(btArray);
  }

文件与Base64互转

  /// <summary>
  /// 文件转Base64字符串
  /// </summary>
  /// <param name="fileName"></param>
  /// <returns></returns>
  public static string Base64File(string fileName)
  {
      FileStream filestream = new FileStream(fileName, FileMode.Open);

      byte[] bt = new byte[filestream.Length];

      //调用read读取方法  
      filestream.Read(bt, 0, bt.Length);
      string base64Str = Convert.ToBase64String(bt);
      filestream.Close();

      return base64Str;
  }

  /// <summary>
  /// Base64字符串转文件
  /// </summary>
  /// <param name="fileName">目标文件名</param>
  /// <param name="content">待转换base64串</param>
  public static void UnBase64File(string fileName, string content)
  {
      byte[] bpath = Convert.FromBase64String(content);

      using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write))
      {
          fs.Write(bpath, 0, bpath.Length);
          fs.Flush();
      }
  }

上面用到的方法

  /// <summary>
  /// 转换成字符串
  /// </summary>
  private static string Bytes2Str(this IEnumerable<byte> source, string formatStr = "{0:X2}")
  {
      StringBuilder pwd = new StringBuilder();
      foreach (byte btStr in source) { pwd.AppendFormat(formatStr, btStr); }
      return pwd.ToString();
  }

        private static string HashAlgorithmBase(HashAlgorithm hashAlgorithmObj, string source, Encoding encoding)
        {
            byte[] btStr = encoding.GetBytes(source);
            byte[] hashStr = hashAlgorithmObj.ComputeHash(btStr);
            return hashStr.Bytes2Str();
        }