#region 随机key：64位、128位、192位
/// <summary>
/// 获取随机key 【BitType：位数 传入1：64位/8个字符；传入2：128位/16个字符；传入3：192位/24个字符；】
/// </summary>
public static byte[] randomKey(int BitType)
{
try
{
string typeName = "";
int typeSize = 0;
if (BitType == 1)
{
typeName = "DES";
typeSize = 64;
}
if (BitType == 2)
{
typeName = "TripleDES";
typeSize = 128;
}
if (BitType == 3)
{
typeName = "3DES";
typeSize = 192;
}
SymmetricAlgorithm symmProvider = SymmetricAlgorithm.Create(typeName);
symmProvider.KeySize = typeSize;
byte[] bkey = symmProvider.Key;
return bkey;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
#endregion
#region GZip压缩/解压缩字符串
/// <summary>
/// GZip压缩函数(支持版本：2.0),返回字符串
/// </summary>
public static string CompressGZip(byte[] strSource)
{
try
{
if (strSource == null)
throw new System.ArgumentException("字符串为空！");
//byte[] buffer = System.Text.Encoding.UTF8.GetBytes(strSource);
byte[] buffer = strSource;
System.IO.MemoryStream ms = new System.IO.MemoryStream();
System.IO.Compression.GZipStream stream = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Compress, true);
stream.Write(buffer, 0, buffer.Length);
stream.Close();
byte[] buffer1 = ms.ToArray();
ms.Close();
return Convert.ToBase64String(buffer1, 0, buffer1.Length); //将压缩后的byte[]转换为Base64String
}
catch
{
string bnull = "";
return bnull;
}
}
/// <summary>
/// GZip压缩函数(支持版本：2.0),返回字节
/// </summary>
public static byte[] CompressGZipExt(byte[] strSource)
{
try
{
if (strSource == null)
throw new System.ArgumentException("字符串为空！");
//byte[] buffer = System.Text.Encoding.UTF8.GetBytes(strSource);
byte[] buffer = strSource;
System.IO.MemoryStream ms = new System.IO.MemoryStream();
System.IO.Compression.GZipStream stream = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Compress, true);
stream.Write(buffer, 0, buffer.Length);
stream.Close();
byte[] buffer1 = ms.ToArray();
return buffer1;
}
catch
{
byte[] bnull = new byte[0];
return bnull;
}
}
/// <summary>
/// Gzip解压缩函数(支持版本：2.0)【参数strSource：原文；codeType：指定编码类型，值1：Base64，值2：UTF8】
/// </summary>
public static string DecompressGZip(string strSource, int codeType)
{
try
{
if (strSource == null)
throw new System.ArgumentException("字符串不能为空！");
byte[] buffer = Convert.FromBase64String(strSource);
System.IO.MemoryStream ms = new System.IO.MemoryStream();
ms.Write(buffer, 0, buffer.Length);
ms.Position = 0;
System.IO.Compression.GZipStream stream = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Decompress);
stream.Flush();
int nSize = 6000 * 1024 + 256; //字符串不超过6000K
byte[] decompressBuffer = new byte[nSize];
int nSizeIncept = stream.Read(decompressBuffer, 0, nSize);
stream.Close();
string backStr = "";
if (codeType == 1)
{
backStr = System.Convert.ToBase64String(decompressBuffer, 0, nSizeIncept);
}
if (codeType == 2)
{
backStr = System.Text.Encoding.UTF8.GetString(decompressBuffer, 0, nSizeIncept);
}
ms.Close();
return backStr;//转换为普通的字符串
}
catch
{
string bnull = "";
return bnull;
}
}
#endregion
#region 签名算法及摘要
#region MD5签名
/// <summary>
/// MD5签名，然后返回string类型签名数据（1：要签名的参数，2：编码方式）。
/// </summary>
public static string MD5Signature(string dataStr, string codeType)
{
try
{
System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
byte[] t = md5.ComputeHash(System.Text.Encoding.GetEncoding(codeType).GetBytes(dataStr));
System.Text.StringBuilder sb = new System.Text.StringBuilder(32);
for (int i = 0; i < t.Length; i++)
{
sb.Append(t[i].ToString("x").PadLeft(2, '0'));
}
return sb.ToString();
}
catch
{
string bnull = "";
return bnull;
}
}
#endregion
#region MD5/SHA1摘要
/// <summary>
/// MD5摘要，然后返回byte类型摘要数据，传入字符串。
/// </summary>
public static byte[] MD5summary(string strSource)
{
try
{
byte[] bSource = System.Text.Encoding.UTF8.GetBytes(strSource);
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
byte[] result = md5.ComputeHash(bSource);//摘要值
//string backStr = Convert.ToBase64String(result);
return result;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
/// <summary>
/// MD5摘要，然后返回byte类型摘要数据，传入字节。
/// </summary>
public static byte[] MD5summaryExt(byte[] strSource)
{
try
{
// byte[] bSource = System.Text.Encoding.UTF8.GetBytes(strSource);
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
byte[] result = md5.ComputeHash(strSource);//摘要值
//string backStr = Convert.ToBase64String(result);
return result;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
/// <summary>
/// SHA1摘要，然后返回byte类型摘要数据。
/// </summary>
public static byte[] SHA1summary(string strSource)
{
try
{
byte[] bSource = System.Text.Encoding.UTF8.GetBytes(strSource);
SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider();
byte[] HashData = sha.ComputeHash(bSource);
//string backStr = Convert.ToBase64String(HashData);
return HashData;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
#endregion
#region 引用证书非对称签名/验签RSA
/// <summary>
/// 引用证书非对称签名/验签RSA-私钥签名【OriginalString：原文（有中文用utf-8编码的字节）；prikey_path：证书路径；CertificatePW：证书密码；SignType：签名摘要类型（1：MD5，2：SHA1）】
/// </summary>
public static byte[] CerRSASignature(byte[] OriginalString, string prikey_path, string CertificatePW, int SignType)
{
try
{
X509Certificate2 x509_Cer1 = new X509Certificate2(prikey_path, CertificatePW);
RSACryptoServiceProvider rsapri = (RSACryptoServiceProvider)x509_Cer1.PrivateKey;
RSAPKCS1SignatureFormatter f = new RSAPKCS1SignatureFormatter(rsapri);
byte[] result;
switch (SignType)
{
case 1:
f.SetHashAlgorithm("MD5");//摘要算法MD5
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
result = md5.ComputeHash(OriginalString);//摘要值
break;
default:
f.SetHashAlgorithm("SHA1");//摘要算法SHA1
SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider();
result = sha.ComputeHash(OriginalString);//摘要值
break;
}
byte[] SignData = f.CreateSignature(result);
return SignData;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
/// <summary>
/// 引用证书非对称签名/验签RSA-公钥验签【OriginalString：原文（有中文用utf-8编码的字节）；SignatureString：签名字符；pubkey_path：证书路径；CertificatePW：证书密码；SignType：签名摘要类型（1：MD5，2：SHA1）】
/// </summary>
public static bool CerRSAVerifySignature(byte[] OriginalString, byte[] SignatureString, string pubkey_path, string CertificatePW, int SignType)
{
try
{
X509Certificate2 x509_Cer1 = new X509Certificate2(pubkey_path, CertificatePW);
RSACryptoServiceProvider rsapub = (RSACryptoServiceProvider)x509_Cer1.PublicKey.Key;
rsapub.ImportCspBlob(rsapub.ExportCspBlob(false));
RSAPKCS1SignatureDeformatter f = new RSAPKCS1SignatureDeformatter(rsapub);
byte[] HashData;
switch (SignType)
{
case 1:
f.SetHashAlgorithm("MD5");//摘要算法MD5
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
HashData = md5.ComputeHash(OriginalString);
break;
default:
f.SetHashAlgorithm("SHA1");//摘要算法SHA1
SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider();
HashData = sha.ComputeHash(OriginalString);
break;
}
if (f.VerifySignature(HashData, SignatureString))
{
return true;
}
else
{
return false;
}
}
catch
{
return false;
}
}
#endregion
#region 引用证书非对称加密/解密RSA
/// <summary>
/// 引用证书非对称加密/解密RSA-公钥加密获取密文【DataToEncrypt：原文（有中文用utf-8编码的字节）；pubkey_path：证书路径；CertificatePW：证书密码】
/// </summary>
public static byte[] CerRSAEncrypt(byte[] DataToEncrypt, string pubkey_path, string CertificatePW)
{
try
{
X509Certificate2 x509_Cer1 = new X509Certificate2(pubkey_path, CertificatePW);
RSACryptoServiceProvider rsapub = (RSACryptoServiceProvider)x509_Cer1.PublicKey.Key;
byte[] bytes_Cypher_Text = rsapub.Encrypt(DataToEncrypt, false);
return bytes_Cypher_Text;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
/// <summary>
/// 引用证书非对称加密/解密RSA-私钥解密获取原文【DataToDecrypt：密文；prikey_path：证书路径；CertificatePW：证书密码】【原文有中文返回字节用utf-8编码转换成字符】
/// </summary>
public static byte[] CerRSADecrypt(byte[] DataToDecrypt, string prikey_path, string CertificatePW)
{
try
{
X509Certificate2 x509_Cer2 = new X509Certificate2(prikey_path, CertificatePW);
RSACryptoServiceProvider rsapri = (RSACryptoServiceProvider)x509_Cer2.PrivateKey;
byte[] bytes_Plain_Text = rsapri.Decrypt(DataToDecrypt, false);
return bytes_Plain_Text;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
#endregion
#region Des 64Bit 对称加密/解密算法
/// <summary>
/// Des 64Bit 算法加密字串【DataToEncrypt：原文；ekey：随机密码，8个字符】【原文有中文传入的原文字符用utf-8编码转换成字节】
/// </summary>
public static byte[] DesEncrypt(byte[] DataToEncrypt, byte[] ekey)
{
try
{
SymmetricAlgorithm mCSP = new DESCryptoServiceProvider();
ICryptoTransform ct;
MemoryStream ms;
CryptoStream cs;
//向量指定的是：byte[] eiv ={0,0,0,0,0,0,0,0};
byte[] eiv = CodingToByte("AAAAAAAAAAA=", 1);
ct = mCSP.CreateEncryptor(ekey, eiv);
ms = new MemoryStream();
cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
cs.Write(DataToEncrypt, 0, DataToEncrypt.Length);
cs.FlushFinalBlock();
cs.Close();
return ms.ToArray();
}
catch
{
byte[] bnull = { };
return bnull;
}
}
/// <summary>
/// Des 64Bit 算法解密字串【DataToDecrypt：密文；ekey：随机密码，8个字符】【原文有中文返回字节用utf-8编码转换成字符】
/// </summary>
public static byte[] DesDecrypt(byte[] DataToDecrypt, byte[] ekey)
{
try
{
SymmetricAlgorithm mCSP = new DESCryptoServiceProvider();
ICryptoTransform ct;
MemoryStream ms;
CryptoStream cs;
//向量指定的是：byte[] eiv ={0,0,0,0,0,0,0,0};
byte[] eiv = CodingToByte("AAAAAAAAAAA=", 1);
ct = mCSP.CreateDecryptor(ekey, eiv);
ms = new MemoryStream();
cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
cs.Write(DataToDecrypt, 0, DataToDecrypt.Length);
cs.FlushFinalBlock();
cs.Close();
return ms.ToArray();
}
catch
{
byte[] bnull = { };
return bnull;
}
}
#endregion
#region TripleDes 128Bit 对称加密/解密算法
/// <summary>
/// TripleDes 128Bit 算法加密字串【DataToEncrypt：原文；priKkey：随机密码，十六个字符】【原文有中文传入的原文字符用utf-8编码转换成字节】
/// </summary>
public static byte[] TripleDesEncrypt(byte[] DataToEncrypt, byte[] ekey)
{
try
{
SymmetricAlgorithm mCSP = new TripleDESCryptoServiceProvider();
ICryptoTransform ct;
MemoryStream ms;
CryptoStream cs;
//向量指定的是：byte[] eiv ={0,0,0,0,0,0,0,0};
byte[] eiv = CodingToByte("AAAAAAAAAAA=", 1);
ct = mCSP.CreateEncryptor(ekey, eiv);
ms = new MemoryStream();
cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
cs.Write(DataToEncrypt, 0, DataToEncrypt.Length);
cs.FlushFinalBlock();
cs.Close();
return ms.ToArray();
}
catch
{
byte[] bnull = { };
return bnull;
}
}
/// <summary>
/// TripleDes 128Bit 算法解密字串【DataToDecrypt：密文；priKkey：随机密码，十六个字符】【原文有中文返回字节用utf-8编码转换成字符】
/// </summary>
public static byte[] TripleDesDecrypt(byte[] DataToDecrypt, byte[] ekey)
{
try
{
SymmetricAlgorithm mCSP = new TripleDESCryptoServiceProvider();
ICryptoTransform ct;
MemoryStream ms;
CryptoStream cs;
//向量指定的是：byte[] eiv ={0,0,0,0,0,0,0,0};
byte[] eiv = CodingToByte("AAAAAAAAAAA=", 1);
ct = mCSP.CreateDecryptor(ekey, eiv);
ms = new MemoryStream();
cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
cs.Write(DataToDecrypt, 0, DataToDecrypt.Length);
cs.FlushFinalBlock();
cs.Close();
return ms.ToArray();
}
catch
{
byte[] bnull = { };
return bnull;
}
}
#endregion
#region Aes 128Bit 对称加密/解密算法
/// <summary>
/// AES加密 128Bit 算法加密字串【Data：原文；bKey：随机密码，16个字符】【原文有中文传入的原文字符用utf-8编码转换成字节】
/// </summary>
public static byte[] AesEncrypt(byte[] Data, byte[] bKey)
{
try
{
//向量指定的是：byte[] bVector ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
byte[] bVector = Convert.FromBase64String("AAAAAAAAAAAAAAAAAAAAAA==");
byte[] Cryptograph = null; // 加密后的密文
Rijndael Aes = Rijndael.Create();
// 开辟一块内存流
using (MemoryStream Memory = new MemoryStream())
{
// 把内存流对象包装成加密流对象
using (CryptoStream Encryptor = new CryptoStream(Memory,
Aes.CreateEncryptor(bKey, bVector),
CryptoStreamMode.Write))
{
// 明文数据写入加密流
Encryptor.Write(Data, 0, Data.Length);
Encryptor.FlushFinalBlock();
Cryptograph = Memory.ToArray();
}
}
return Cryptograph;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
/// <summary>
/// Aes解密 128Bit 算法解密字串【Data：原文；bKey：随机密码，16个字符】【原文有中文传入的原文字符用utf-8编码转换成字节】
/// </summary>
public static byte[] AesDecrypt(byte[] Data, byte[] bKey)
{
try
{
//向量指定的是：byte[] bVector ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
byte[] bVector = Convert.FromBase64String("AAAAAAAAAAAAAAAAAAAAAA==");
byte[] original = null; // 解密后的明文
Rijndael Aes = Rijndael.Create();
// 开辟一块内存流，存储密文
using (MemoryStream Memory = new MemoryStream(Data))
{
// 把内存流对象包装成加密流对象
using (CryptoStream Decryptor = new CryptoStream(Memory,
Aes.CreateDecryptor(bKey, bVector),
CryptoStreamMode.Read))
{
// 明文存储区
using (MemoryStream originalMemory = new MemoryStream())
{
byte[] Buffer = new byte[1024];
Int32 readBytes = 0;
while ((readBytes = Decryptor.Read(Buffer, 0, Buffer.Length)) > 0)
{
originalMemory.Write(Buffer, 0, readBytes);
}
original = originalMemory.ToArray();
}
}
}
return original;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
#endregion
#region 对称加密算法集合（Aes，Des，TripleDes）
/// <summary>
/// 对称加密算法集合【orgData：原数据；enKey：密码；EncryptType：加密类型|1：AES 需要128位key，2：DES 需要64位key，3：TripleDES 需要128位key】
/// </summary>
/// <param name="orgData">原文</param>
/// <param name="enKey">密码</param>
/// <param name="EncryptType">解密算法类型</param>
/// <returns>SymmetryEncryptType：密文</returns>
public static byte[] SymmetryEncryptType(byte[] orgData, byte[] enKey, int EncryptType)
{
try
{
byte[] badkData = null;
if (EncryptType == 1)
{
badkData = bigpay.AesEncrypt(orgData, enKey);
}
if (EncryptType == 2)
{
badkData = bigpay.DesEncrypt(orgData, enKey);
}
if (EncryptType == 3)
{
badkData = bigpay.TripleDesEncrypt(orgData, enKey);
}
return badkData;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
/// <summary>
/// 对称解密算法集合【orgData：原数据；enKey：密码；EncryptType：加密类型|1：AES 需要128位key，2：DES 需要64位key，3：TripleDES 需要128位key】
/// </summary>
/// <param name="orgData">密文</param>
/// <param name="enKey">密码</param>
/// <param name="DecryptType">解密算法类型</param>
/// <returns>SymmetryDecryptType：明文</returns>
public static byte[] SymmetryDecryptType(byte[] orgData, byte[] enKey, int DecryptType)
{
try
{
byte[] badkData = null;
if (DecryptType == 1)
{
badkData = bigpay.AesDecrypt(orgData, enKey);
}
if (DecryptType == 2)
{
badkData = bigpay.DesDecrypt(orgData, enKey);
}
if (DecryptType == 3)
{
badkData = bigpay.TripleDesDecrypt(orgData, enKey);
}
return badkData;
}
catch
{
byte[] bnull = { };
return bnull;
}
}
#endregion
#endregion
845
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
