using System; using System.IO; using System.Security.Cryptography; using System.Text; namespace NugetLibs.HelpTool { /// <summary> /// 加解密帮助类 /// </summary> public class EncryptHelper { #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 Base64编码和解码 /// <summary> /// 把字符串进行Base64编码 /// </summary> /// <param name="value">字符串</param> /// <returns>Base64编码字符串</returns> public static string ToBase64String(string value) { if (string.IsNullOrEmpty(value)) { return value; } byte[] bytes = Encoding.UTF8.GetBytes(value); return Convert.ToBase64String(bytes); } /// <summary> /// 把字符串进行Base64解码 /// </summary> /// <param name="value">Base64编码字符串</param> /// <returns>原字符串</returns> public static string UnBase64String(string value) { if (string.IsNullOrEmpty(value)) { return value; } byte[] bytes = Convert.FromBase64String(value); return Encoding.UTF8.GetString(bytes); } #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 = DefaultDESKey, 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 ByteStrConvertHelper.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 = DefaultDESKey, 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 = ByteStrConvertHelper.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 ByteStrConvertHelper.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 = ByteStrConvertHelper.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 ByteStrConvertHelper.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="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 ByteStrConvertHelper.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 = ByteStrConvertHelper.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 = ByteStrConvertHelper.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; } /// <summary> /// AES解密 /// </summary> /// <param name="encryptByte">密文字节数组</param> /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param> /// <param name="iv">加密向量(16到19字节)</param> /// <param name="mode">加密模式</param> /// <param name="padding">填充模式</param> /// <returns>明文字节数组</returns> public static byte[] AESDecryptToBytes(byte[] encryptByte, 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 = encryptByte; 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 = ByteStrConvertHelper.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 = ByteStrConvertHelper.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 ByteStrConvertHelper.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 ByteStrConvertHelper.ToString(bytes); } /// <summary> /// 把字符串进行32位MD5加密 /// </summary> /// <param name="str">要加密的字符串</param> /// <returns>加密的字符串</returns> public static string HashMD532(string str) { MD5 md5 = new MD5CryptoServiceProvider(); byte[] strByte = Encoding.Default.GetBytes(str); byte[] md5Data = md5.ComputeHash(strByte); md5.Clear(); StringBuilder strBuilder = new StringBuilder(); for (var i = 0; i < md5Data.Length; i++) { strBuilder.Append(md5Data[i].ToString("x2")); } return strBuilder.ToString(); } /// <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 ByteStrConvertHelper.ToString(md5.ComputeHash(bytes)).Substring(8, 16); } /// <summary> /// 对字符串进行SHA1散列 /// </summary> /// <param name="data">需要哈稀的字符串</param> /// <param name="isBase64">是否采用Base64</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 ByteStrConvertHelper.ToString(StrRes); } /// <summary> /// SHA256加密，不可逆转 /// </summary> /// <param name="data">string data:被加密的字符串</param> /// <param name="isBase64">是否采用Base64</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 ByteStrConvertHelper.ToString(byte1); } /// <summary> /// SHA384加密，不可逆转 /// </summary> /// <param name="data">string data:被加密的字符串</param> /// <param name="isBase64">是否采用Base64</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 ByteStrConvertHelper.ToString(byte1); } /// <summary> /// SHA512加密，不可逆转 /// </summary> /// <param name="data">string data:被加密的字符串</param> /// <param name="isBase64">是否采用Base64</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 ByteStrConvertHelper.ToString(byte1); } #endregion #region 带混淆字符串的散列 /// <summary> /// 对字符串进行HmacMD5散列 /// </summary> /// <param name="key">密钥</param> /// <param name="data">需要哈稀的字符串</param> /// <param name="isBase64">是否采用Base64</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 ByteStrConvertHelper.ToString(StrRes); } /// <summary> /// 对字符串进行HmacSHA1散列 /// </summary> /// <param name="key">密钥</param> /// <param name="data">需要哈稀的字符串</param> /// <param name="isBase64">是否采用Base64</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 ByteStrConvertHelper.ToString(StrRes); } /// <summary> /// 对字符串进行HmacSHA256散列 /// </summary> /// <param name="key">密钥</param> /// <param name="data">需要哈稀的字符串</param> /// <param name="isBase64">是否采用Base64</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 ByteStrConvertHelper.ToString(StrRes); } /// <summary> /// 对字符串进行HmacSHA384散列 /// </summary> /// <param name="key">密钥</param> /// <param name="data">需要哈稀的字符串</param> /// <param name="isBase64">是否采用Base64</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 ByteStrConvertHelper.ToString(StrRes); } /// <summary> /// 对字符串进行HmacSHA512散列 /// </summary> /// <param name="key">密钥</param> /// <param name="data">需要哈稀的字符串</param> /// <param name="isBase64">是否采用Base64</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 ByteStrConvertHelper.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 ByteStrConvertHelper.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 = ByteStrConvertHelper.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 ByteStrConvertHelper.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 = ByteStrConvertHelper.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 } }