C#中常用加密算法、md5、sha1、rsa、base64、des
侧边栏壁纸
  • 累计撰写 62 篇文章
  • 累计收到 20 条评论
C#

C#中常用加密算法、md5、sha1、rsa、base64、des

一缕清风
2021-01-17 / 0 评论 / 43 阅读 / 正在检测是否收录...

简介

本文主要讲解一下C#常用的那些加密算法,包括MD5加密、SHA1加密、Base64加密、Des加密、RSA加密等,需要的朋友可以参考下

MD5

  • MD5加密是最常见的加密方式,因为MD5是不可逆的,所以很多系统的密码都是用MD5加密保存的。
  • 虽然MD5是不可以解码的,但因为MD5加密的字符串是固定的,所以,理论上只需要建立一个庞大的数据库,把所有的字符串都加密一遍,那就可以解码所有的MD5密文了。
  • 虽然建立一个可以解码全部MD5的数据库不太现实,但一个五六百亿数据量的数据库就可以解码绝大部分字符串了,毕竟大部分情况下,我们的密码也是有长度限制的。
  • 实际应用中MD5有64位和32位加密之分。
public static string GetMd532(string ConvertString)
{
  MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
  string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(ConvertString)), 4, 8);
  t2 = t2.Replace("-", "");
 
  return t2;
} 
public static string Get64Md5(string str)
{
  string cl = str;
  string pwd = "";
  var md5 = MD5.Create();
  byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(cl)); 
  for (int i = 0; i < s.Length; i++)
  {
    pwd = pwd + s[i].ToString("X2");
  } 
  return pwd;
} 

SHA1

  • SHA1加密算法与MD5加密类似,都是不可逆的,只是算法不同。所以也和MD5一样,存在容易被大数据解码的问题。
private static readonly Encoding Encoder = Encoding.UTF8;
public static String Sha1(String content )
{
  try
  {
    SHA1 sha1 = new SHA1CryptoServiceProvider();//创建SHA1对象
    byte[] bytes_in = Encoder.GetBytes(content);//将待加密字符串转为byte类型
    byte[] bytes_out = sha1.ComputeHash(bytes_in);//Hash运算
    sha1.Dispose();//释放当前实例使用的所有资源
    String result = BitConverter.ToString(bytes_out);//将运算结果转为string类型
    result = result.Replace("-", "").ToUpper();
    return result;
  }
  catch (Exception ex)
  {
    return ex.Message;
  }
}

Base64

  • 准确的来说,Base64是一种编码,而不是加密,通常Base64编码后字符串会用于传输数据。不过也因为Base64编码后字符串具有不可读性,所以,不少人也把他当做加密算法来使用。
        private static readonly Encoding Encoder = Encoding.UTF8;
        /// <summary>
        /// base64编码
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>
        public static string EncodeBase64(string source)
        {
            string target = "";
            byte[] bytes = Encoder.GetBytes(source);
            try
            {
                target = Convert.ToBase64String(bytes);
            }
            catch
            {
                target = source;
            }
            return target;
        }

        /// <summary>
        /// base64解码
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>
        public static string DecodeBase64(string result)
        {
            string decode = "";
            byte[] bytes = Convert.FromBase64String(result);
            try
            {
                decode = Encoder.GetString(bytes);
            }
            catch
            {
                decode = result;
            }
            return decode;
        }

DES

  • DES加密算法是对密钥进行保密,而公开算法,即只有拥有相同密钥的人才能解密。
  • DES加密算法对密钥有要求,必须是8个字符,如12345678这样的。
  • DESCryptoServiceProvider类的Mode属性可以指定加密运算模式,加密运算模式如下。
  1. CBC:密码块链模式。
  2. ECB:电子密码本模式。
  3. OFB:输出反馈模式。
  4. CFB:密码反馈模式。
  5. CTS:密码文本窃取模式。
public static string Encrypt(string stringToEncrypt, string shortKey)
{
  DESCryptoServiceProvider des = new DESCryptoServiceProvider();
  byte[] inputByteArray = Encoding.GetEncoding("UTF-8").GetBytes(stringToEncrypt);
  des.Key = ASCIIEncoding.UTF8.GetBytes(shortKey);
  des.IV = ASCIIEncoding.UTF8.GetBytes(shortKey);
  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);
  }
  ret.ToString();
  return ret.ToString();
}
public static string Decrypt(string stringToDecrypt, string sKey)
{
  DESCryptoServiceProvider des = new DESCryptoServiceProvider();
 
  byte[] inputByteArray = new byte[stringToDecrypt.Length / 2];
  for (int x = 0; x < stringToDecrypt.Length / 2; x++)
  {
    int i = (Convert.ToInt32(stringToDecrypt.Substring(x * 2, 2), 16));
    inputByteArray[x] = (byte)i;
  }
  des.Key = ASCIIEncoding.UTF8.GetBytes(sKey);
  des.IV = ASCIIEncoding.UTF8.GetBytes(sKey);
  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());
}

RSA

  • RSA加密采用公钥加密,私钥解密的模式。Https的数字证书也是使用这种模式加密的。
public static string RSADecrypt(string xmlPrivateKey, string enptStr)
{
  RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
  provider.FromXmlString(xmlPrivateKey);
  byte[] rgb = Convert.FromBase64String(enptStr);
  byte[] bytes = provider.Decrypt(rgb, RSAEncryptionPadding.OaepSHA1);
  return new UnicodeEncoding().GetString(bytes);
}
public static string RSAEncrypt(string xmlPublicKey, string enptStr)
{
  RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
  provider.FromXmlString(xmlPublicKey);
  byte[] bytes = new UnicodeEncoding().GetBytes(enptStr);
  return Convert.ToBase64String(provider.Encrypt(bytes, RSAEncryptionPadding.OaepSHA1));
}
  • 但是RSA加密有个特点,就是他对被加密的字符串有长度限制;待加密的字节数不能超过密钥的长度值除以8再减去11(即:RSACryptoServiceProvider.KeySize / 8 - 11,而加密后得到密文的字节数,正好是密钥的长度值除以 8(即:RSACryptoServiceProvider.KeySize / 8)。注:该长度指的是byte[]数组的长度,而不是字符串的长度,简单来说,就是被加密字符串不能太长。
  • 但是,在真实的业务中,我们需要加密的字符串往往会很长,那么,RSA又对被加密字符串有长度限制,我们该怎么办呢?很简单,把待加密的字符串拆开,每段长度都小于等于限制长度,然后分段加密,这样,问题就解决了。
public static String SubRSAEncrypt(string xmlPublicKey, string enptStr)
{
  RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
  provider.FromXmlString(xmlPublicKey);
  Byte[] bytes = Encoder.GetBytes(enptStr);
  int MaxBlockSize = provider.KeySize / 8 - 11;  //加密块最大长度限制
 
  if (bytes.Length <= MaxBlockSize)
    return Convert.ToBase64String(provider.Encrypt(bytes, false));
 
  using (MemoryStream PlaiStream = new MemoryStream(bytes))
  using (MemoryStream CrypStream = new MemoryStream())
  {
    Byte[] Buffer = new Byte[MaxBlockSize];
    int BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
 
    while (BlockSize > 0)
    {
      Byte[] ToEncrypt = new Byte[BlockSize];
      Array.Copy(Buffer, 0, ToEncrypt, 0, BlockSize);
 
      Byte[] Cryptograph = provider.Encrypt(ToEncrypt, false);
      CrypStream.Write(Cryptograph, 0, Cryptograph.Length);
 
      BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
    }
 
    return Convert.ToBase64String(CrypStream.ToArray(), Base64FormattingOptions.None);
  }
 
}
/// 
 
/// 分段解密,应对长字符串
/// 
/// 
/// 
/// 
public static String SubRSADecrypt(string xmlPublicKey, string enptStr)
{
  RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
  provider.FromXmlString(xmlPublicKey);
  Byte[] bytes = Convert.FromBase64String(enptStr);
  int MaxBlockSize = provider.KeySize / 8;  //解密块最大长度限制
 
  if (bytes.Length <= MaxBlockSize)
    return Encoder.GetString(provider.Decrypt(bytes, false));
 
  using (MemoryStream CrypStream = new MemoryStream(bytes))
  using (MemoryStream PlaiStream = new MemoryStream())
  {
    Byte[] Buffer = new Byte[MaxBlockSize];
    int BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);
 
    while (BlockSize > 0)
    {
      Byte[] ToDecrypt = new Byte[BlockSize];
      Array.Copy(Buffer, 0, ToDecrypt, 0, BlockSize);
 
      Byte[] Plaintext = provider.Decrypt(ToDecrypt, false);
      PlaiStream.Write(Plaintext, 0, Plaintext.Length);
 
      BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);
    }
 
    return Encoder.GetString(PlaiStream.ToArray());
  }
}
1

评论 (0)

取消