.NET 加密算法封装大全

各位看官，自己把Default的一些密码写上。

#region 文件注释
/**************************************************************
 * this file is part of ipvp Project(CLR: 4.0.30319.42000 GUID:$GUID$)
 * 
 * Author	: LINUX/yuanshian
 * Mail     : a-shyuan@microsoft.com
 * Machinename	: LINUX
 * Create Date	: 2017/1/20 17:58:38
 * ItemName     : EncryptTools
 * Description	: 
 * 
 * *************************************************************
 * History
 * -------------------------------------------------------------
 * Modify Date	:
 * Modify User	:
 * Description	:
 * 
 * *************************************************************/
#endregion

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace Microsoft.BlueVision.Framework
{
	/// <summary>
	/// 加解密工具类
	/// </summary>
	public class EncryptionHelper
	{
		#region 默认密钥定义
		/// <summary>
		/// 默认加密密钥
		/// </summary>
		public const string DefaultDESKey = @"12345678";
		/// <summary>
		/// 默认加密向量
		/// </summary>
		public const string DefaultDESIV = @"1234567812345678";
		/// <summary>
		/// 默认加密密钥
		/// </summary>
		public const string Default3DESKey = @"123456781234567812345678";
		/// <summary>
		/// 默认加密向量
		/// </summary>
		public const string Default3DESIV = @"1234567812345678";
		/// <summary>
		/// 获取密钥
		/// </summary>
		public const string DefaultAESKey = @"12345678123456781234567812345678";
		/// <summary>
		/// 获取向量
		/// </summary>
		public const string DefaultAESIV = @"1234567812345678";
		/// <summary>
		/// 默认加密密钥
		/// </summary>
		public const string DefaultRC2Key = @"1234567812345678";
		/// <summary>
		/// 默认加密向量
		/// </summary>
		public const string DefaultRC2IV = @"1234567812345678";
		/// <summary>
		/// 默认的RSA公钥
		/// </summary>
		public const string DefaultRSAPublicKey = @"<RSAKeyValue>xxx</RSAKeyValue>";
		/// <summary>
		/// 默认的RSA密钥
		/// </summary>
		public const string DefaultRSAPrivateKey = @"<RSAKeyValue>ccc</RSAKeyValue>";
		#endregion

		#region 对称加密算法

		#region 3DES对称加密算法
		/// <summary>
		/// 使用指定的128字节的密钥对8字节数组进行3Des加密
		/// </summary>
		/// <param name="plainStr"></param>
		/// <param name="key">密钥长度，可以为128（16字节），或是192（24字节）</param>
		/// <param name="iv">加密向量长度64位以上(8个字节以上)</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>已加密的字符串</returns>
		public static string TripleDESEncrypt(string plainStr, string key = Default3DESKey, string iv = Default3DESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);
			byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);

			string encrypt = null;
			var tdsc = new TripleDESCryptoServiceProvider();
			try
			{
				//加密模式，偏移
				tdsc.Mode = mode;
				tdsc.Padding = padding;
				using (var mStream = new MemoryStream())
				{
					using (var cStream = new CryptoStream(mStream, tdsc.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
					{
						cStream.Write(byteArray, 0, byteArray.Length);
						cStream.FlushFinalBlock();
						if (isBase64Code)
							encrypt = Convert.ToBase64String(mStream.ToArray());
						else
							ConvertHelper.ToString(mStream.ToArray());
					}
				}
			}
			catch { }
			tdsc.Clear();

			return encrypt;
		}
		/// <summary>
		/// 使用指定的128字节的密钥对8字节数组进行3Des解密
		/// </summary>
		/// <param name="encryptStr"></param>
		/// <param name="key">密钥长度，可以为128（16字节），或是192（24字节）</param>
		/// <param name="iv">加密向量长度64位以上(8个字节以上)</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>已解密的字符串</returns>
		public static string TripleDESDecrypt(string encryptStr, string key = Default3DESKey, string iv = Default3DESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);
			byte[] byteArray;
			if (isBase64Code)
				byteArray = Convert.FromBase64String(encryptStr);
			else
				byteArray = ConvertHelper.ToBytes(encryptStr);

			string decrypt = null;
			var tdsc = new TripleDESCryptoServiceProvider();
			try
			{
				tdsc.Mode = mode;
				tdsc.Padding = padding;
				using (var mStream = new MemoryStream())
				{
					using (var cStream = new CryptoStream(mStream, tdsc.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
					{
						cStream.Write(byteArray, 0, byteArray.Length);
						cStream.FlushFinalBlock();
						decrypt = Encoding.UTF8.GetString(mStream.ToArray());
					}
				}
			}
			catch { }
			tdsc.Clear();

			return decrypt;
		}
		#endregion

		#region DES对称加密算法
		/// <summary>
		/// DES加密
		/// </summary>
		/// <param name="plainStr">明文字符串</param>
		/// <param name="key">加密密钥长度64位(8字节)</param>
		/// <param name="iv">加密向量长度64位以上(8个字节以上)</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>密文</returns>
		public static string DESEncrypt(string plainStr, string key = DefaultDESKey, string iv = DefaultDESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);
			byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);

			string encrypt = null;
			var des = new DESCryptoServiceProvider();
			try
			{
				des.Mode = mode;
				des.Padding = padding;
				using (var mStream = new MemoryStream())
				{
					using (var cStream = new CryptoStream(mStream, des.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
					{
						cStream.Write(byteArray, 0, byteArray.Length);
						cStream.FlushFinalBlock();
						if (isBase64Code)
							encrypt = Convert.ToBase64String(mStream.ToArray());
						else
							ConvertHelper.ToString(mStream.ToArray());
					}
				}
			}
			catch { }
			des.Clear();

			return encrypt;
		}

		/// <summary>
		/// DES解密
		/// </summary>
		/// <param name="encryptStr">密文字符串</param>
		/// <param name="key">加密密钥长度64位(8字节)</param>
		/// <param name="iv">加密向量长度64位以上(8个字节以上)</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>明文</returns>
		public static string DESDecrypt(string encryptStr, string key = DefaultDESKey, string iv = DefaultDESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);
			byte[] byteArray;
			if (isBase64Code)
				byteArray = Convert.FromBase64String(encryptStr);
			else
				byteArray = ConvertHelper.ToBytes(encryptStr);

			string decrypt = null;
			var des = new DESCryptoServiceProvider();
			try
			{
				des.Mode = mode;
				des.Padding = padding;
				using (var mStream = new MemoryStream())
				{
					using (var cStream = new CryptoStream(mStream, des.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
					{
						cStream.Write(byteArray, 0, byteArray.Length);
						cStream.FlushFinalBlock();
						decrypt = Encoding.UTF8.GetString(mStream.ToArray());
					}
				}
			}
			catch { }
			des.Clear();

			return decrypt;
		}
		#endregion

		#region AES加密算法
		/// <summary>
		/// AES加密
		/// </summary>
		/// <param name="plainStr">明文字符串</param>
		/// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
		/// <param name="iv">加密向量(16到19字节)</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>密文</returns>
		public static string AESEncrypt(string plainStr, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);
			byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);

			var encrypts = AESEncrypt(byteArray, key, iv, mode, padding);
			if (isBase64Code)
				return Convert.ToBase64String(encrypts);
			else
				return ConvertHelper.ToString(encrypts);
		}
		/// <summary>
		/// AES加密
		/// </summary>
		/// <param name="plainbytes">明文字节数组</param>
		/// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
		/// <param name="iv">加密向量(16到19字节)</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>密文</returns>
		public static byte[] AESEncrypt(byte[] plainbytes, string key = DefaultAESKey, string iv = DefaultAESIV, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);
			byte[] byteArray = plainbytes;

			byte[] encrypt = null;
			var aes = Rijndael.Create();
			try
			{
				aes.Padding = padding;
				aes.Mode = mode;
				using (var mStream = new MemoryStream())
				{
					using (var cStream = new CryptoStream(mStream, aes.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
					{
						cStream.Write(byteArray, 0, byteArray.Length);
						cStream.FlushFinalBlock();
					}
					encrypt = mStream.ToArray();
				}
			}
			catch { }
			aes.Clear();

			return encrypt;
		}
		/// <summary>
		/// AES加密
		/// </summary>
		/// <param name="plainbytes">明文字节数组</param>
		/// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
		/// <param name="iv">加密向量(16到19字节)</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>密文</returns>
		public static string AESEncrypt(byte[] plainbytes, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);

			var encrypts = AESEncrypt(plainbytes, key, iv, mode, padding);
			if (isBase64Code)
				return Convert.ToBase64String(encrypts);
			else
				return ConvertHelper.ToString(encrypts);
		}
		/// <summary>
		/// AES解密
		/// </summary>
		/// <param name="encryptStr">密文字符串</param>
		/// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
		/// <param name="iv">加密向量(16到19字节)</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>明文</returns>
		public static string AESDecrypt(string encryptStr, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);
			byte[] byteArray;
			if (isBase64Code)
				byteArray = Convert.FromBase64String(encryptStr);
			else
				byteArray = ConvertHelper.ToBytes(encryptStr);

			string decrypt = null;
			var aes = Rijndael.Create();
			try
			{
				aes.Mode = mode;
				aes.Padding = padding;
				using (var mStream = new MemoryStream())
				{
					using (var cStream = new CryptoStream(mStream, aes.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
					{
						cStream.Write(byteArray, 0, byteArray.Length);
						cStream.FlushFinalBlock();
						decrypt = Encoding.UTF8.GetString(mStream.ToArray());
					}
				}
			}
			catch { }
			aes.Clear();

			return decrypt;
		}
		/// <summary>
		/// AES解密
		/// </summary>
		/// <param name="encryptStr">密文字符串</param>
		/// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
		/// <param name="iv">加密向量(16到19字节)</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>明文</returns>
		public static byte[] AESDecryptToBytes(string encryptStr, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);
			byte[] byteArray;
			if (isBase64Code)
				byteArray = Convert.FromBase64String(encryptStr);
			else
				byteArray = ConvertHelper.ToBytes(encryptStr);

			byte[] decrypt = null;
			var aes = Rijndael.Create();
			try
			{
				aes.Mode = mode;
				aes.Padding = padding;
				using (var mStream = new MemoryStream())
				{
					using (var cStream = new CryptoStream(mStream, aes.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
					{
						cStream.Write(byteArray, 0, byteArray.Length);
						cStream.FlushFinalBlock();
					}
					decrypt = mStream.ToArray();
				}
			}
			catch { }
			aes.Clear();

			return decrypt;
		}
		#endregion

		#region RC2加密算法
		/// <summary>
		/// RC2加密
		/// </summary>
		/// <param name="plainStr">明文字符串</param>
		/// <param name="key">加密密钥支持40~128长度，可以每8位递增（5到16个长度的字符串）</param>
		/// <param name="iv">加密向量64位以上（8个字节上去字符串）</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>密文</returns>
		public static string RC2Encrypt(string plainStr, string key = DefaultRC2Key, string iv = DefaultRC2IV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);
			byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);

			string encrypt = null;
			var rc2 = new RC2CryptoServiceProvider();
			try
			{
				rc2.Padding = padding;
				rc2.Mode = mode;
				using (var mStream = new MemoryStream())
				{
					using (var cStream = new CryptoStream(mStream, rc2.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
					{
						cStream.Write(byteArray, 0, byteArray.Length);
						cStream.FlushFinalBlock();
						if (isBase64Code)
							encrypt = Convert.ToBase64String(mStream.ToArray());
						else
							encrypt = ConvertHelper.ToString(mStream.ToArray());
					}
				}
			}
			catch { }
			rc2.Clear();

			return encrypt;
		}

		/// <summary>
		/// RC2解密
		/// </summary>
		/// <param name="encryptStr">明文字符串</param>
		/// <param name="key">加密密钥支持40~128长度，可以每8位递增（5到16个长度的字符串）</param>
		/// <param name="iv">加密向量64位以上（8个字节上去字符串）</param>
		/// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
		/// <param name="mode">加密模式</param>
		/// <param name="padding">填充模式</param>
		/// <returns>明文</returns>
		public static string RC2Decrypt(string encryptStr, string key = DefaultRC2Key, string iv = DefaultRC2IV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
		{
			byte[] bKey = Encoding.UTF8.GetBytes(key);
			byte[] bIV = Encoding.UTF8.GetBytes(iv);
			byte[] byteArray;
			if (isBase64Code)
				byteArray = Convert.FromBase64String(encryptStr);
			else
				byteArray = ConvertHelper.ToBytes(encryptStr);

			string decrypt = null;
			var rc2 = new RC2CryptoServiceProvider();
			try
			{
				rc2.Mode = mode;
				rc2.Padding = padding;
				using (var mStream = new MemoryStream())
				{
					using (var cStream = new CryptoStream(mStream, rc2.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
					{
						cStream.Write(byteArray, 0, byteArray.Length);
						cStream.FlushFinalBlock();
						decrypt = Encoding.UTF8.GetString(mStream.ToArray());
					}
				}
			}
			catch { }
			rc2.Clear();

			return decrypt;
		}
		#endregion

		#endregion

		#region 哈稀算法

		#region 获取哈稀散列值
		/// <summary>
		/// 使用md5计算散列
		/// </summary>
		/// <param name="source">要用MD5算散列的字节数据</param>
		/// <returns>经过MD5算散列后的数据</returns>
		public static byte[] Hash(byte[] source)
		{
			if ((source == null) || (source.Length == 0)) throw new ArgumentException("source is not valid");
			var m = MD5.Create();
			return m.ComputeHash(source);
		}
		/// <summary>
		/// 对传入的明文密码进行Hash加密,密码不能为中文
		/// </summary>
		/// <param name="oriPassword">需要加密的明文密码</param>
		/// <returns>经过Hash加密的密码</returns>
		public static string HashPassword(string oriPassword)
		{
			if (string.IsNullOrEmpty(oriPassword))
				throw new ArgumentException("oriPassword is valid");

			var acii = new ASCIIEncoding();
			var hashedBytes = Hash(acii.GetBytes(oriPassword));
			return ConvertHelper.ToString(hashedBytes);
		}
		/// <summary>
		/// 计算MD5
		/// </summary>
		/// <param name="data">要算MD5的字符串</param>
		/// <param name="isBase64Code">是否是Base64编码</param>
		/// <returns>MD5字符串</returns>
		public static string HashMD5(string data, bool isBase64Code = false)
		{
			if (string.IsNullOrEmpty(data)) return "";
			var md5 = new MD5CryptoServiceProvider();
			byte[] bytes = Encoding.UTF8.GetBytes(data);
			bytes = md5.ComputeHash(bytes);
			md5.Clear();
			if (isBase64Code)
				return Convert.ToBase64String(bytes);
			else
				return ConvertHelper.ToString(bytes);
		}
		/// <summary>
		/// 生成16位的MD5散列值
		/// </summary>
		/// <param name="data">要算MD5的字符串</param>
		/// <returns></returns>
		public static string HashMD516(string data)
		{
			var md5 = new MD5CryptoServiceProvider();
			byte[] bytes = Encoding.UTF8.GetBytes(data);
			return ConvertHelper.ToString(md5.ComputeHash(bytes)).Substring(8, 16);
		}

		/// <summary>
		/// 对字符串进行SHA1散列
		/// </summary>
		/// <param name="data">需要哈稀的字符串</param>
		/// <param name="isBase64"></param>
		/// <returns>密文</returns>
		public static string HashSHA1(string data, bool isBase64 = false)
		{
			var StrRes = Encoding.UTF8.GetBytes(data);
			HashAlgorithm iSHA = new SHA1CryptoServiceProvider();
			StrRes = iSHA.ComputeHash(StrRes);
			if (isBase64)
				return Convert.ToBase64String(StrRes);
			else
				return ConvertHelper.ToString(StrRes);
		}

		/// <summary>
		/// SHA256加密，不可逆转
		/// </summary>
		/// <param name="data">string data:被加密的字符串</param>
		/// <param name="isBase64"></param>
		/// <returns>返回加密后的字符串</returns>
		public static string HashSHA256(string data, bool isBase64 = false)
		{
			SHA256 s256 = new SHA256CryptoServiceProvider();
			byte[] byte1 = Encoding.UTF8.GetBytes(data);
			byte1 = s256.ComputeHash(byte1);
			s256.Clear();
			if (isBase64)
				return Convert.ToBase64String(byte1);
			else
				return ConvertHelper.ToString(byte1);
		}

		/// <summary>
		/// SHA384加密，不可逆转
		/// </summary>
		/// <param name="data">string data:被加密的字符串</param>
		/// <param name="isBase64"></param>
		/// <returns>返回加密后的字符串</returns>
		public static string HashSHA384(string data, bool isBase64 = false)
		{
			SHA384 s384 = new SHA384CryptoServiceProvider();
			byte[] byte1 = Encoding.UTF8.GetBytes(data);
			byte1 = s384.ComputeHash(byte1);
			s384.Clear();
			if (isBase64)
				return Convert.ToBase64String(byte1);
			else
				return ConvertHelper.ToString(byte1);
		}

		/// <summary>
		/// SHA512加密，不可逆转
		/// </summary>
		/// <param name="data">string data:被加密的字符串</param>
		/// <param name="isBase64"></param>
		/// <returns>返回加密后的字符串</returns>
		public static string HashSHA512(string data, bool isBase64 = false)
		{
			SHA512 s512 = new SHA512CryptoServiceProvider();
			byte[] byte1 = Encoding.Default.GetBytes(data);
			byte1 = s512.ComputeHash(byte1);
			s512.Clear();
			if (isBase64)
				return Convert.ToBase64String(byte1);
			else
				return ConvertHelper.ToString(byte1);
		}
		#endregion

		#region 带混淆字符串的散列
		/// <summary>
		/// 对字符串进行HmacMD5散列
		/// </summary>
		/// <param name="key">密钥</param>
		/// <param name="data">需要哈稀的字符串</param>
		/// <param name="isBase64"></param>
		/// <returns>密文</returns>
		public static string HmacMD5(string key, string data, bool isBase64 = false)
		{
			var StrRes = Encoding.UTF8.GetBytes(data);
			var bkey = Encoding.UTF8.GetBytes(key);
			var hmacSha1 = new HMACMD5(bkey);
			StrRes = hmacSha1.ComputeHash(StrRes);
			if (isBase64)
				return Convert.ToBase64String(StrRes);
			else
				return ConvertHelper.ToString(StrRes);
		}

		/// <summary>
		/// 对字符串进行HmacSHA1散列
		/// </summary>
		/// <param name="key">密钥</param>
		/// <param name="data">需要哈稀的字符串</param>
		/// <param name="isBase64"></param>
		/// <returns>密文</returns>
		public static string HmacSHA1(string key, string data, bool isBase64 = false)
		{
			var StrRes = Encoding.UTF8.GetBytes(data);
			var bkey = Encoding.UTF8.GetBytes(key);
			HMACSHA1 hmacSha1 = new HMACSHA1(bkey);
			StrRes = hmacSha1.ComputeHash(StrRes);
			if (isBase64)
				return Convert.ToBase64String(StrRes);
			else
				return ConvertHelper.ToString(StrRes);
		}

		/// <summary>
		/// 对字符串进行HmacSHA256散列
		/// </summary>
		/// <param name="key">密钥</param>
		/// <param name="data">需要哈稀的字符串</param>
		/// <param name="isBase64"></param>
		/// <returns>密文</returns>
		public static string HmacSHA256(string key, string data, bool isBase64 = false)
		{
			var StrRes = Encoding.UTF8.GetBytes(data);
			var bkey = Encoding.UTF8.GetBytes(key);
			var hmacSha1 = new HMACSHA256(bkey);
			StrRes = hmacSha1.ComputeHash(StrRes);
			if (isBase64)
				return Convert.ToBase64String(StrRes);
			else
				return ConvertHelper.ToString(StrRes);
		}

		/// <summary>
		/// 对字符串进行HmacSHA384散列
		/// </summary>
		/// <param name="key">密钥</param>
		/// <param name="data">需要哈稀的字符串</param>
		/// <param name="isBase64"></param>
		/// <returns>密文</returns>
		public static string HmacSHA384(string key, string data, bool isBase64 = false)
		{
			var StrRes = Encoding.UTF8.GetBytes(data);
			var bkey = Encoding.UTF8.GetBytes(key);
			var hmacSha1 = new HMACSHA384(bkey);
			StrRes = hmacSha1.ComputeHash(StrRes);
			if (isBase64)
				return Convert.ToBase64String(StrRes);
			else
				return ConvertHelper.ToString(StrRes);
		}

		/// <summary>
		/// 对字符串进行HmacSHA512散列
		/// </summary>
		/// <param name="key">密钥</param>
		/// <param name="data">需要哈稀的字符串</param>
		/// <param name="isBase64"></param>
		/// <returns>密文</returns>
		public static string HmacSHA512(string key, string data, bool isBase64 = false)
		{
			var StrRes = Encoding.UTF8.GetBytes(data);
			var bkey = Encoding.UTF8.GetBytes(key);
			var hmacSha1 = new HMACSHA512(bkey);
			StrRes = hmacSha1.ComputeHash(StrRes);
			if (isBase64)
				return Convert.ToBase64String(StrRes);
			else
				return ConvertHelper.ToString(StrRes);
		}
		#endregion

		#endregion

		#region 非对称加密算法
		/// <summary>
		/// RSA加密
		/// </summary>
		/// <param name="plaintData">明文</param>
		/// <param name="publicKey">RSA公钥</param>
		/// <param name="isBase64">输出数据是否用Base64编码</param>
		/// <returns></returns>
		public static string RSAEncrypt(string plaintData, string publicKey = DefaultRSAPublicKey, bool isBase64 = false)
		{
			var rsa = new RSACryptoServiceProvider();
			rsa.FromXmlString(publicKey);
			var cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(plaintData), false);
			if (isBase64)
				return Convert.ToBase64String(cipherbytes);
			else
				return ConvertHelper.ToString(cipherbytes);
		}
		/// <summary>
		/// RSA解密
		/// </summary>
		/// <param name="encryptData">密文</param>
		/// <param name="privateKey">RSA私钥</param>
		/// <param name="isBase64">密文数据是否用Base64编码</param>
		/// <returns></returns>
		public static string RSADecrypt(string encryptData, string privateKey = DefaultRSAPublicKey, bool isBase64 = false)
		{
			byte[] bData;
			if (isBase64)
				bData = Convert.FromBase64String(encryptData);
			else
				bData = ConvertHelper.ToBytes(encryptData);
			var rsa = new RSACryptoServiceProvider();
			rsa.FromXmlString(privateKey);
			var cipherbytes = rsa.Decrypt(bData, false);
			return Encoding.UTF8.GetString(cipherbytes);
		}
		/// <summary>
		/// RSA加密
		/// </summary>
		/// <param name="plaintData">明文</param>
		/// <param name="publicKey">RSA公钥</param>
		/// <param name="isBase64">输出数据是否用Base64编码</param>
		/// <returns></returns>
		public static string RSAEncrypt(string plaintData, RSAParameters publicKey, bool isBase64 = false)
		{
			var rsa = new RSACryptoServiceProvider();
			rsa.ImportParameters(publicKey);
			var cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(plaintData), false);
			if (isBase64)
				return Convert.ToBase64String(cipherbytes);
			else
				return ConvertHelper.ToString(cipherbytes);
		}
		/// <summary>
		/// RSA解密
		/// </summary>
		/// <param name="encryptData">密文</param>
		/// <param name="privateKey">RSA私钥</param>
		/// <param name="isBase64">密文数据是否用Base64编码</param>
		/// <returns></returns>
		public static string RSADecrypt(string encryptData, RSAParameters privateKey, bool isBase64 = false)
		{
			byte[] bData;
			if (isBase64)
				bData = Convert.FromBase64String(encryptData);
			else
				bData = ConvertHelper.ToBytes(encryptData);
			var rsa = new RSACryptoServiceProvider();
			rsa.ImportParameters(privateKey);
			var cipherbytes = rsa.Decrypt(bData, false);
			return Encoding.UTF8.GetString(cipherbytes);
		}
		#endregion
	}

	/// <summary>
	/// RSA加解密类
	/// </summary>
	public class RSACryptionHelper
	{
		#region RSA 加密解密 

		#region RSA 的密钥产生 
		/// <summary>
		/// RSA 的密钥产生 产生私钥 和公钥 
		/// </summary>
		/// <param name="xmlKeys"></param>
		/// <param name="xmlPublicKey"></param>
		public void RSAKey(out string xmlKeys, out string xmlPublicKey)
		{
			var rsa = new RSACryptoServiceProvider();
			xmlKeys = rsa.ToXmlString(true);
			xmlPublicKey = rsa.ToXmlString(false);
		}
		#endregion

		#region RSA的加密函数 
		//############################################################################## 
		//RSA 方式加密 
		//说明KEY必须是XML的行式,返回的是字符串 
		//在有一点需要说明！！该加密方式有 长度 限制的！！ 
		//############################################################################## 

		//RSA的加密函数  string
		/// <summary>
		/// RSA加密
		/// </summary>
		/// <param name="xmlPublicKey"></param>
		/// <param name="m_strEncryptString"></param>
		/// <returns></returns>
		public string RSAEncrypt(string xmlPublicKey, string m_strEncryptString)
		{

			byte[] PlainTextBArray;
			byte[] CypherTextBArray;
			string Result;
			RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
			rsa.FromXmlString(xmlPublicKey);
			PlainTextBArray = (new UnicodeEncoding()).GetBytes(m_strEncryptString);
			CypherTextBArray = rsa.Encrypt(PlainTextBArray, false);
			Result = Convert.ToBase64String(CypherTextBArray);
			return Result;

		}
		//RSA的加密函数 byte[]
		/// <summary>
		/// RSA解密
		/// </summary>
		/// <param name="xmlPublicKey"></param>
		/// <param name="EncryptString"></param>
		/// <returns></returns>
		public string RSAEncrypt(string xmlPublicKey, byte[] EncryptString)
		{

			byte[] CypherTextBArray;
			string Result;
			var rsa = new RSACryptoServiceProvider();
			rsa.FromXmlString(xmlPublicKey);
			CypherTextBArray = rsa.Encrypt(EncryptString, false);
			Result = Convert.ToBase64String(CypherTextBArray);
			return Result;

		}
		#endregion

		#region RSA的解密函数 
		/// <summary>
		/// RSA的解密函数  string
		/// </summary>
		/// <param name="xmlPrivateKey"></param>
		/// <param name="m_strDecryptString"></param>
		/// <returns></returns>
		public string RSADecrypt(string xmlPrivateKey, string m_strDecryptString)
		{
			byte[] PlainTextBArray;
			byte[] DypherTextBArray;
			string Result;
			var rsa = new RSACryptoServiceProvider();
			rsa.FromXmlString(xmlPrivateKey);
			PlainTextBArray = Convert.FromBase64String(m_strDecryptString);
			DypherTextBArray = rsa.Decrypt(PlainTextBArray, false);
			Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
			return Result;

		}

		/// <summary>
		/// RSA的解密函数  byte
		/// </summary>
		/// <param name="xmlPrivateKey"></param>
		/// <param name="DecryptString"></param>
		/// <returns></returns>
		public string RSADecrypt(string xmlPrivateKey, byte[] DecryptString)
		{
			byte[] DypherTextBArray;
			string Result;
			var rsa = new RSACryptoServiceProvider();
			rsa.FromXmlString(xmlPrivateKey);
			DypherTextBArray = rsa.Decrypt(DecryptString, false);
			Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
			return Result;

		}
		#endregion

		#endregion

		#region RSA 数字签名 

		#region 获取Hash描述表
		/// <summary>
		/// 获取Hash描述表
		/// </summary>
		/// <param name="m_strSource"></param>
		/// <param name="HashData"></param>
		/// <returns></returns>
		public bool GetHash(string m_strSource, ref byte[] HashData)
		{
			//从字符串中取得Hash描述 
			byte[] Buffer;
			var MD5 = HashAlgorithm.Create("MD5");
			Buffer = Encoding.UTF8.GetBytes(m_strSource);
			HashData = MD5.ComputeHash(Buffer);

			return true;
		}

		/// <summary>
		/// 获取Hash描述表
		/// </summary>
		/// <param name="m_strSource"></param>
		/// <param name="strHashData"></param>
		/// <returns></returns>
		public bool GetHash(string m_strSource, ref string strHashData)
		{
			//从字符串中取得Hash描述 
			byte[] Buffer;
			byte[] HashData;
			var MD5 = HashAlgorithm.Create("MD5");
			Buffer = Encoding.UTF8.GetBytes(m_strSource);
			HashData = MD5.ComputeHash(Buffer);

			strHashData = Convert.ToBase64String(HashData);
			return true;

		}

		/// <summary>
		/// 获取Hash描述表
		/// </summary>
		/// <param name="objFile"></param>
		/// <param name="HashData"></param>
		/// <returns></returns>
		public bool GetHash(FileStream objFile, ref byte[] HashData)
		{
			//从文件中取得Hash描述 
			var MD5 = HashAlgorithm.Create("MD5");
			HashData = MD5.ComputeHash(objFile);
			objFile.Close();

			return true;

		}

		/// <summary>
		/// 获取Hash描述表
		/// </summary>
		/// <param name="objFile"></param>
		/// <param name="strHashData"></param>
		/// <returns></returns>
		public bool GetHash(FileStream objFile, ref string strHashData)
		{
			//从文件中取得Hash描述 
			byte[] HashData;
			var MD5 = HashAlgorithm.Create("MD5");
			HashData = MD5.ComputeHash(objFile);
			objFile.Close();

			strHashData = Convert.ToBase64String(HashData);

			return true;
		}
		#endregion

		#region RSA 签名
		/// <summary>
		/// RSA 签名
		/// </summary>
		/// <param name="privateKey">Xml私钥</param>
		/// <param name="hashData">待签名Hash描述</param>
		/// <param name="signatureData">签名后的结果</param>
		/// <returns></returns>
		public bool Signature(string privateKey, byte[] hashData, ref byte[] signatureData)
		{
			try
			{
				var RSA = new RSACryptoServiceProvider();
				RSA.FromXmlString(privateKey);
				var RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
				//设置签名的算法为MD5 
				RSAFormatter.SetHashAlgorithm("MD5");
				//执行签名 
				signatureData = RSAFormatter.CreateSignature(hashData);
				return true;
			}
			catch
			{
				return false;
			}
		}

		/// <summary>
		/// RSA 签名
		/// </summary>
		/// <param name="privateKey">Xml私钥</param>
		/// <param name="hashData">待签名Hash描述</param>
		/// <param name="signatureData">签名后的结果</param>
		/// <returns></returns>
		public bool Signature(string privateKey, byte[] hashData, ref string signatureData)
		{
			try
			{
				var RSA = new RSACryptoServiceProvider();
				RSA.FromXmlString(privateKey);
				var RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
				//设置签名的算法为MD5 
				RSAFormatter.SetHashAlgorithm("MD5");
				//执行签名 
				signatureData = Convert.ToBase64String(RSAFormatter.CreateSignature(hashData));
				return true;
			}
			catch
			{
				return false;
			}
		}

		/// <summary>
		/// RSA 签名
		/// </summary>
		/// <param name="privateKey">Xml私钥</param>
		/// <param name="hashData">待签名Hash描述</param>
		/// <param name="signatureData">签名后的结果</param>
		/// <returns></returns>
		public bool Signature(string privateKey, string hashData, ref byte[] signatureData)
		{
			try
			{
				var RSA = new RSACryptoServiceProvider();
				RSA.FromXmlString(privateKey);
				var RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
				//设置签名的算法为MD5 
				RSAFormatter.SetHashAlgorithm("MD5");
				//执行签名 
				var bHashData = Convert.FromBase64String(hashData);
				signatureData = RSAFormatter.CreateSignature(bHashData);

				return true;
			}
			catch { return false; }
		}

		/// <summary>
		/// RSA 签名
		/// </summary>
		/// <param name="privateKey">Xml私钥</param>
		/// <param name="hashData">待签名Hash描述</param>
		/// <param name="signatureData">签名后的结果</param>
		/// <returns></returns>
		public bool Signature(string privateKey, string hashData, ref string signatureData)
		{
			try
			{
				var RSA = new RSACryptoServiceProvider();
				RSA.FromXmlString(privateKey);
				var RSAFormatter = new RSAPKCS1SignatureFormatter(RSA);
				//设置签名的算法为MD5 
				RSAFormatter.SetHashAlgorithm("MD5");
				//执行签名 
				var bHashData = Convert.FromBase64String(hashData);
				signatureData = Convert.ToBase64String(RSAFormatter.CreateSignature(bHashData));
				return true;
			}
			catch { return false; }
		}
		#endregion

		#region RSA 签名验证 
		/// <summary>
		/// RSA签名验证（验证时，函数RSADeformatter.VerifySignature先用公钥解密signatureData）
		/// </summary>
		/// <param name="publicKey">Xml字符串公钥</param>
		/// <param name="hashData">Hash描述(刚生成的报文摘要)</param>
		/// <param name="signatureData">签名后的结果(等待验证的私钥加密的Hash描述)</param>
		/// <returns></returns>
		public bool VerifySignature(string publicKey, byte[] hashData, byte[] signatureData)
		{
			var RSA = new RSACryptoServiceProvider();
			RSA.FromXmlString(publicKey);
			var RSADeformatter = new RSAPKCS1SignatureDeformatter(RSA);
			//指定解密的时候HASH算法为MD5 
			RSADeformatter.SetHashAlgorithm("MD5");
			return (RSADeformatter.VerifySignature(hashData, signatureData));
		}
		/// <summary>
		/// RSA签名验证（验证时，函数RSADeformatter.VerifySignature先用公钥解密signatureData）
		/// </summary>
		/// <param name="publicKey">Xml字符串公钥</param>
		/// <param name="hashData">Hash描述(刚生成的报文摘要)</param>
		/// <param name="signatureData">签名后的结果(等待验证的私钥加密的Hash描述)</param>
		/// <returns></returns>
		public bool VerifySignature(string publicKey, string hashData, byte[] signatureData)
		{
			byte[] bHashData = Convert.FromBase64String(hashData);
			return VerifySignature(publicKey, bHashData, signatureData);
		}
		/// <summary>
		/// RSA签名验证（验证时，函数RSADeformatter.VerifySignature先用公钥解密signatureData）
		/// </summary>
		/// <param name="publicKey">Xml字符串公钥</param>
		/// <param name="hashData">Hash描述(刚生成的报文摘要)</param>
		/// <param name="signatureData">签名后的结果(等待验证的私钥加密的Hash描述)</param>
		/// <returns></returns>
		public bool VerifySignature(string publicKey, byte[] hashData, string signatureData)
		{
			var bSignatureData = Convert.FromBase64String(signatureData);
			return VerifySignature(publicKey, hashData, bSignatureData);
		}
		/// <summary>
		/// RSA签名验证（验证时，函数RSADeformatter.VerifySignature先用公钥解密signatureData）
		/// </summary>
		/// <param name="publicKey">Xml字符串公钥</param>
		/// <param name="hashData">Hash描述(刚生成的报文摘要)</param>
		/// <param name="signatureData">签名后的结果(等待验证的私钥加密的Hash描述)</param>
		/// <returns></returns>
		public bool VerifySignature(string publicKey, string hashData, string signatureData)
		{
			var bHashData = Convert.FromBase64String(hashData);
			var bSignatureData = Convert.FromBase64String(signatureData);
			return VerifySignature(publicKey, bHashData, bSignatureData);
		}
		#endregion

		#endregion
	}
	/// <summary>
	/// 密钥结构
	/// </summary>
	public struct RSAKeyInfo
	{
		//RSA的密钥有两种表现形式，一种是通过RSAParameters对象来表现，另一种是通过XML字符串来表现，当通过默认构造函数构造一个RSACryptoServiceProvider实例的时候，会自动生成一对公私钥，可以通过调用其ExportParameters()方法或ToXmlString()方法导出密钥(分别对应前面所述的两种表现形式)。这两种表现形式的本质是一样的，前者是一个含有八个字段的结构体，后者是一个含有八个XML配置节的XMLNODE，这八个元素的名称分别为：
		//D、DP、DQ、Exponent、InverseQ、Modulus、Q
		//要了解这些元素的意义，首先需要了解构造公私钥的过程
		//A) 找到两个大素数P和q，相乘得n
		//B) 选择一个数e，它小于n且与n互素，得到公钥(e, n)
		//C) 得到一个数d，它满足(d* e)mod((p-1)*(q-1))=1,得到私钥(d, n)
		//D) 纯文本m到密文c的加密过程c=(m^e)mod n，解密过程为m=(c^d)mod n, 加密解密过程是可逆的。
		//了解了密钥的构造过程，下面是这八个元素的详细解释：
		//RSAParameters 字段 Contains 对应的 PKCS #1 字段
		//D			d，私钥指数					privateExponent
		//DP		d mod(p - 1)				exponent1
		//DQ		d mod(q - 1)				exponent2
		//Exponent	e，公钥指数					publicExponent
		//InverseQ	(InverseQ)(q) = 1 mod p		Coefficient
		//Modulus	N							Modulus
		//P			P							prime1
		//Q			Q							prime2
		//第三列的“PKCS”指的是一种RSA加密标准，类似于这样的标准有多个，下文会进行叙述！
	}
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace Microsoft.BlueVision.Framework
{
	/// <summary>
	/// 类型转化帮助类
	/// </summary>
	public static class ConvertHelper
	{
		/// <summary>
		/// 转换字符流成字符串
		/// </summary>
		/// <param name="bytes"></param>
		/// <returns></returns>
		public static string ToString(byte[] bytes)
		{
			var sb = new StringBuilder(64);
			foreach (byte iByte in bytes) sb.AppendFormat("{0:x2}", iByte);
			return sb.ToString();
		}

		/// <summary>
		/// 转换成Byte数组
		/// </summary>
		/// <param name="hexString"></param>
		/// <returns></returns>
		public static byte[] ToBytes(string hexString)
		{
			if (hexString == null) return null;
			var data = new byte[hexString.Length / 2];
			int h, l;
			for (var i = 0; i < data.Length; i++)
			{
				h = (hexString[2 * i] > 57 ? hexString[2 * i] - 'A' + 10 : hexString[2 * i] - '0') << 4 & 0x000000F0;
				l = (hexString[2 * i + 1] > 57 ? hexString[2 * i + 1] - 'A' + 10 : hexString[2 * i + 1] - '0') & 0x0000000F;

				data[i] = (byte)(h | l);
			}

			return data;
		}
	}
}