c#net rsa证书签名加密方aesdes3desrar压缩.docx
《c#net rsa证书签名加密方aesdes3desrar压缩.docx》由会员分享，可在线阅读，更多相关《c#net rsa证书签名加密方aesdes3desrar压缩.docx（15页珍藏版）》请在冰豆网上搜索。
c#netrsa证书签名加密方aesdes3desrar压缩
安全策略关系
usingSystem;
usingSystem.Data;
usingSystem.Configuration;
usingSystem.Collections;
usingSystem.Web;
usingSystem.Web.Security;
usingSystem.Web.UI;
usingSystem.Web.UI.WebControls;
usingSystem.Web.UI.WebControls.WebParts;
usingSystem.Web.UI.HtmlControls;
usingSystem.Security.Cryptography;
usingSystem.Security.Cryptography.X509Certificates;
usingSystem.Collections.Generic;
usingSystem.Text;
usingSystem.IO;
usingSystem.IO.Compression;
namespaceasap
{
///
///asap应用类，包含签名/验签，压缩/解压缩，加密/解密，字符类型转换
///
publicclassasapApp
{
#region参数类型转换
///
///获取字节值，将字符型转换成字节型【strData：
原字符；TypeId编码类型1：
Base64编码，2：
UTF8编码，3：
ASCII编码】
///
publicstaticbyte[]CodingToByte（stringstrData,intTypeId）
{
try
{
byte[]byteData;
switch（TypeId）
{
case1:
byteData=Convert.FromBase64String（strData）;
break;
case2:
byteData=System.Text.Encoding.UTF8.GetBytes（strData）;
break;
default:
System.Text.ASCIIEncodingByteConverter=newASCIIEncoding（）;
byteData=ByteConverter.GetBytes（strData）;
break;
}
returnbyteData;
}
catch
{
byte[]bnull={};
returnbnull;
}
}
///
///获取字符值，将字节型转换成字符型【byteData：
原字节；TypeId编码类型1：
Base64编码，2：
UTF8编码，3：
ASCII编码】
///
publicstaticstringCodingToString（byte[]byteData,intTypeId）
{
try
{
stringstringData;
switch（TypeId）
{
case1:
stringData=System.Convert.ToBase64String（byteData）;
break;
case2:
stringData=System.Text.Encoding.UTF8.GetString（byteData）;
break;
default:
System.Text.ASCIIEncodingByteConverter=newASCIIEncoding（）;
stringData=ByteConverter.GetString（byteData）;
break;
}
returnstringData;
}
catch
{
stringbnull="";
returnbnull;
}
}
#endregion
#region随机key：
64位、128位、192位
///
///获取随机key【BitType：
位数传入1：
64位/8个字符；传入2：
128位/16个字符；传入3：
192位/24个字符；】
///
publicstaticbyte[]randomKey（intBitType）
{
try
{
stringtypeName="";
inttypeSize=0;
if（BitType==1）
{
typeName="DES";
typeSize=64;
}
if（BitType==2）
{
typeName="TripleDES";
typeSize=128;
}
if（BitType==3）
{
typeName="3DES";
typeSize=192;
}
SymmetricAlgorithmsymmProvider=SymmetricAlgorithm.Create（typeName）;
symmProvider.KeySize=typeSize;
byte[]bkey=symmProvider.Key;
returnbkey;
}
catch
{
byte[]bnull={};
returnbnull;
}
}
#endregion
#regionGZip压缩/解压缩字符串
///
///GZip压缩函数（支持版本：
2.0）
///
publicstaticstringCompressGZip（byte[]strSource）
{
try
{
if（strSource==null）
thrownewSystem.ArgumentException（"字符串为空！
"）;
//byte[]buffer=System.Text.Encoding.UTF8.GetBytes（strSource）;
byte[]buffer=strSource;
System.IO.MemoryStreamms=newSystem.IO.MemoryStream（）;
System.IO.Compression.GZipStreamstream=newSystem.IO.Compression.GZipStream（ms,System.IO.Compression.CompressionMode.Compress,true）;
stream.Write（buffer,0,buffer.Length）;
stream.Close（）;
byte[]buffer1=ms.ToArray（）;
ms.Close（）;
returnConvert.ToBase64String（buffer1,0,buffer1.Length）;//将压缩后的byte[]转换为Base64String
}
catch
{
stringbnull="";
returnbnull;
}
}
///
///Gzip解压缩函数（支持版本：
2.0）【参数strSource：
原文；codeType：
指定编码类型，值1：
Base64，值2：
UTF8】
///
publicstaticstringDecompressGZip（stringstrSource,intcodeType）
{
try
{
if（strSource==null）
thrownewSystem.ArgumentException（"字符串不能为空！
"）;
byte[]buffer=Convert.FromBase64String（strSource）;
System.IO.MemoryStreamms=newSystem.IO.MemoryStream（）;
ms.Write（buffer,0,buffer.Length）;
ms.Position=0;
System.IO.Compression.GZipStreamstream=newSystem.IO.Compression.GZipStream（ms,System.IO.Compression.CompressionMode.Decompress）;
stream.Flush（）;
intnSize=6000*1024+256;//字符串不超过6000K
byte[]decompressBuffer=newbyte[nSize];
intnSizeIncept=stream.Read（decompressBuffer,0,nSize）;
stream.Close（）;
stringbackStr="";
if（codeType==1）
{
backStr=System.Convert.ToBase64String（decompressBuffer,0,nSizeIncept）;
}
if（codeType==2）
{
backStr=System.Text.Encoding.UTF8.GetString（decompressBuffer,0,nSizeIncept）;
}
ms.Close（）;
returnbackStr;//转换为普通的字符串
}
catch
{
stringbnull="";
returnbnull;
}
}
#endregion
#region签名算法及摘要
#regionMD5签名
///
///MD5签名，然后返回string类型签名数据（1：
要签名的参数，2：
编码方式）。
///
publicstaticstringMD5Signature（stringdataStr,stringcodeType）
{
try
{
System.Security.Cryptography.MD5md5=newSystem.Security.Cryptography.MD5CryptoServiceProvider（）;
byte[]t=md5.ComputeHash（System.Text.Encoding.GetEncoding（codeType）.GetBytes（dataStr））;
System.Text.StringBuildersb=newSystem.Text.StringBuilder（32）;
for（inti=0;i{
sb.Append（t[i].ToString（"x"）.PadLeft（2,'0'））;
}
returnsb.ToString（）;
}
catch
{
stringbnull="";
returnbnull;
}
}
#endregion
#regionMD5/SHA1摘要
///
///MD5摘要，然后返回byte类型摘要数据。
///
publicstaticbyte[]MD5summary（stringstrSource）
{
try
{
byte[]bSource=System.Text.Encoding.UTF8.GetBytes（strSource）;
MD5CryptoServiceProvidermd5=newMD5CryptoServiceProvider（）;
byte[]result=md5.ComputeHash（bSource）;//摘要值
//stringbackStr=Convert.ToBase64String（result）;
returnresult;
}
catch
{
byte[]bnull={};
returnbnull;
}
}
///
///SHA1摘要，然后返回byte类型摘要数据。
///
publicstaticbyte[]SHA1summary（stringstrSource）
{
try
{
byte[]bSource=System.Text.Encoding.UTF8.GetBytes（strSource）;
SHA1CryptoServiceProvidersha=newSHA1CryptoServiceProvider（）;
byte[]HashData=sha.ComputeHash（bSource）;
//stringbackStr=Convert.ToBase64String（HashData）;
returnHashData;
}
catch
{
byte[]bnull={};
returnbnull;
}
}
#endregion
#region引用证书非对称签名/验签RSA
///
///引用证书非对称签名/验签RSA-私钥签名【OriginalString：
原文（有中文用utf-8编码的字节）；prikey_path：
证书路径；CertificatePW：
证书密码；SignType：
签名摘要类型（1：
MD5，2：
SHA1）】
///
publicstaticbyte[]CerRSASignature（byte[]OriginalString,stringprikey_path,stringCertificatePW,intSignType）
{
try
{
X509Certificate2x509_Cer1=newX509Certificate2（prikey_path,CertificatePW）;
RSACryptoServiceProviderrsapri=（RSACryptoServiceProvider）x509_Cer1.PrivateKey;
RSAPKCS1SignatureFormatterf=newRSAPKCS1SignatureFormatter（rsapri）;
byte[]result;
switch（SignType）
{
case1:
f.SetHashAlgorithm（"MD5"）;//摘要算法MD5
MD5CryptoServiceProvidermd5=newMD5CryptoServiceProvider（）;
result=md5.ComputeHash（OriginalString）;//摘要值
break;
default:
f.SetHashAlgorithm（"SHA1"）;//摘要算法SHA1
SHA1CryptoServiceProvidersha=newSHA1CryptoServiceProvider（）;
result=sha.ComputeHash（OriginalString）;//摘要值
break;
}
byte[]SignData=f.CreateSignature（result）;
returnSignData;
}
catch
{
byte[]bnull={};
returnbnull;
}
}
///
///引用证书非对称签名/验签RSA-公钥验签【OriginalString：
原文（有中文用utf-8编码的字节）；SignatureString：
签名字符；pubkey_path：
证书路径；CertificatePW：
证书密码；SignType：
签名摘要类型（1：
MD5，2：
SHA1）】
///
publicstaticboolCerRSAVerifySignature（byte[]OriginalString,byte[]SignatureString,stringpubkey_path,stringCertificatePW,intSignType）
{
try
{
X509Certificate2x509_Cer1=newX509Certificate2（pubkey_path,CertificatePW）;
RSACryptoServiceProviderrsapub=（RSACryptoServiceProvider）x509_Cer1.PublicKey.Key;
rsapub.ImportCspBlob（rsapub.ExportCspBlob（false））;
RSAPKCS1SignatureDeformatterf=newRSAPKCS1SignatureDeformatter（rsapub）;
byte[]HashData;
switch（SignType）
{
case1:
f.SetHashAlgorithm（"MD5"）;//摘要算法MD5
MD5CryptoServiceProvidermd5=newMD5CryptoServiceProvider（）;
HashData=md5.ComputeHash（OriginalString）;
break;
default:
f.SetHashAlgorithm（"SHA1"）;//摘要算法SHA1
SHA1CryptoServiceProvidersha=newSHA1CryptoServiceProvider（）;
HashData=sha.ComputeHash（OriginalString）;
break;
}
if（f.VerifySignature（HashData,SignatureString））
{
returntrue;
}
else
{
returnfalse;
}
}
catch
{
returnfalse;
}
}
#endregion
#region引用证书非对称加密/解密RSA
///
///引用证书非对称加密/解密RSA-公钥加密获取密文【DataToEncrypt：
原文（有中文用utf-8编码的字节）；pubkey_path：
证书路径；CertificatePW：
证书密码】
///
publicstaticbyte[]CerRSAEncrypt（byte[]DataToEncrypt,stringpubkey_path,stringCertificatePW）
{
try
{
X509Certificate2x509_Cer1=newX509Certificate2（pubkey_path,CertificatePW）;
RSACryptoServiceProviderrsapub=（RSACryptoServiceProvider）x509_Cer1.PublicKey.Key;
byte[]bytes_Cypher_Text=rsapub.Encrypt（DataToEncrypt,false）;
returnbytes_Cypher_Text;
}
catch
{
byte[]bnull={};
returnbnull;
}
}
///
///引用证书非对称加密/解密RSA-私钥解密获取原文【DataToDecrypt：
密文；prikey_path：
证书路径；CertificatePW：
证书密码】【原文有中文返回字节用utf-8编码转换成字符】
///
publicstaticbyte[]CerRSADecrypt（byte[]DataToDecrypt,stringprikey_path,stringCertificatePW）
{
try
{
X509Certificate2x509_Cer2=newX509Certificate2（prikey_path,CertificatePW）;
RSACryptoServiceProviderrsapri=（RSACryptoServiceProvider）x509_Cer2.PrivateKey;
byte[]bytes_Plain_Text=rsapri.Decrypt（DataToDecrypt,false）;
returnbytes_Plain_Text;
}
catch
{
byte[]bnull={};
returnbnull;
}
}
#endregion
#regionDes64Bit对称加密/解密算法
///
///Des64Bit算法加密字串【DataToEncrypt：
原文；ekey：
随机密码，8个字符】【原文有中文传入的原文字符用utf-8编码转换成字节】
///
publicstaticbyte[]DesEncrypt（byte[]DataToEncrypt,byte[]ekey）
{
try
{
SymmetricAlgorithmmCSP=newDESCryptoServiceProvider（）;
ICryptoTransformct;
MemoryStreamms;
CryptoStreamcs;
//向量指定的是：
byte[]eiv={0,0,0,0,0,0,0,0};
byte[]eiv=CodingToByte（"AAAAAAAAAAA=",1）;
ct=mCSP.CreateEncryptor（ekey,eiv）;
ms=newMemoryStream（）;
cs=newCryptoStream（ms,ct,CryptoStreamMode.Write）;
cs.Write（DataToEncrypt,0,DataToEncrypt.Length）;
cs.FlushFinalBlock（）;
cs.Close（）;
returnms.ToArray（）;
}
catch
{
byte[]bnull={};
returnbnull;
}
}
///
///Des64Bit算法解密字串【DataToDecrypt：
密文；ekey：
随机密码，8个字符】【原文有中文返回字节用utf-8编码转换成字符】
///
publicstaticbyte[]DesDecrypt（byte[]DataToDecrypt,byte[]
升级会员 