各位看官,自己把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;
}
}
}