MD5 不可逆加密,Des对称可逆加密 ,RSA非对称可逆加密 ,数字证书 SSL

using System.IO;
using System.Security.Cryptography;
using System.Text;namespace EncryptDemo
{
/// <summary>
/// 不可逆加密
/// 1 防止被篡改
/// 2 防止明文存储
/// 3 防止抵赖，数字签名
/// </summary>
public class MD5Encrypt
{
#region MD5
/// <summary>
/// MD5加密,和动网上的16/32位MD5加密结果相同,
/// 使用的UTF8编码
/// </summary>
/// <param name="strSource">待加密的字符串</param>
/// <param name="length">16或32值之一,其它则采用.net默认MD5加密算法</param>
/// <returns>加密后的字串</returns>
public static string Encrypt(string source, int length = )//默认参数
{
HashAlgorithm provider = CryptoConfig.CreateFromName("MD5") as HashAlgorithm;
if (string.IsNullOrEmpty(source)) return string.Empty; byte[] bytes = Encoding.UTF8.GetBytes(source);// Encoding.ASCII.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();
}
/// <summary>
/// MD5加密,和动网上的16/32位MD5加密结果相同,
/// 使用的UTF8编码
/// 为文件加密方法
/// </summary>
/// <param name="strSource">待加密的文件路径</param>
/// <param name="length">16或32值之一,其它则采用.net默认MD5加密算法</param>
/// <returns>加密后的字串</returns>
public static string EncryptFile(string pathFile, int length = )//默认参数
{
using (FileStream fsRead = new FileStream(pathFile, FileMode.Open))
{
int fsLen = (int)fsRead.Length;
byte[] heByte = new byte[fsLen];
int r = fsRead.Read(heByte, , heByte.Length);
string myStr = System.Text.Encoding.UTF8.GetString(heByte);
return Encrypt(myStr, length);
}
}
#endregion MD5
}
}

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;namespace EncryptDemo
{
/// <summary>
/// DES AES Blowfish
///  对称加密算法的优点是速度快，
///  缺点是密钥管理不方便，要求共享密钥。
/// 可逆对称加密 密钥长度8
/// </summary>
public class DesEncrypt
{
//8位长度
private static string KEY = "Anker_张1";
private static byte[] rgbKey = ASCIIEncoding.ASCII.GetBytes(KEY.Substring(, ));
private static byte[] rgbIV = ASCIIEncoding.ASCII.GetBytes(KEY.Insert(, "Z").Substring(, ));
/// <summary>
/// DES 加密
/// </summary>
/// <param name="strValue"></param>
/// <returns></returns>
public static string Encrypt(string strValue)
{
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(strValue);
sWriter.Flush();
crypStream.FlushFinalBlock();
memStream.Flush();
return Convert.ToBase64String(memStream.GetBuffer(), , (int)memStream.Length);
}
}
/// <summary>
/// DES解密
/// </summary>
/// <param name="EncValue"></param>
/// <returns></returns>
public static string Decrypt(string EncValue)
{
DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
byte[] buffer = Convert.FromBase64String(EncValue); 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());
}
}
}
}

using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;namespace EncryptDemo
{
/// <summary>
/// RSA ECC
/// 可逆非对称加密
/// 非对称加密算法的优点是密钥管理很方便，缺点是速度慢。
/// </summary>
public class RsaEncrypt
{
/// <summary>
/// publicKey:加密,privateKey解密
/// </summary>
/// <returns></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>
/// 加密
/// </summary>
/// <param name="content"></param>
/// <param name="publicKey">返还公钥</param>
/// <param name="privateKey">返回密钥</param>
/// <returns>加密后结果</returns>
public static void GetKey(out string publicKey, out string privateKey)
{
RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider();
publicKey = rsaProvider.ToXmlString(false);
privateKey = rsaProvider.ToXmlString(true);
}
/// <summary>
/// 加密：内容+公钥
/// </summary>
/// <param name="content"></param>
/// <param name="publicKey"></param>
/// <returns></returns>
public static string Encrypt(string content, string publicKey)
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(publicKey);
UnicodeEncoding ByteConverter = new UnicodeEncoding();
byte[] DataToEncrypt = ByteConverter.GetBytes(content);
byte[] resultBytes = rsa.Encrypt(DataToEncrypt, false);
return Convert.ToBase64String(resultBytes);
}
/// <summary>
/// 解密 内容+私钥
/// </summary>
/// <param name="content"></param>
/// <param name="privateKey"></param>
/// <returns></returns>
public static string Decrypt(string content, string privateKey)
{
byte[] dataToDecrypt = Convert.FromBase64String(content);
RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
RSA.FromXmlString(privateKey);
byte[] resultBytes = RSA.Decrypt(dataToDecrypt, false);
UnicodeEncoding ByteConverter = new UnicodeEncoding();
return ByteConverter.GetString(resultBytes);
}
}
}