public RSAHelper(RSAType rsaType, string privateKey = null, string publicKey = null)
{
_encoding = Encoding.UTF8;
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey ?? _privateKey);
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey ?? _publicKey);
_hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
}
/// <summary>
/// 实例化RSAHelper
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
private static void InitRSADEncrypt(RSAType rsaType, Encoding encoding)
{
_encoding = encoding;
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(_privateKey);
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(_publicKey);
_hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
}
/// <summary>
/// RSA工具类
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256</param>
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
public RSATool(RSAType rsaType, Encoding encoding, string privateKey, string publicKey)
{
_encoding = encoding;
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
_hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
}
/// <summary>
/// 实例化RSAHelper
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
public RSAHelper(RSAType rsaType, Encoding encoding, string privateKey, string publicKey = null)
{
_encoding = encoding;
if (!string.IsNullOrEmpty(privateKey))
{
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
}
if (!string.IsNullOrEmpty(publicKey))
{
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
}
_hashAlgorithmName = HashAlgorithmName.SHA256;
if (rsaType == RSAType.RSA)
{
_hashAlgorithmName = HashAlgorithmName.SHA1;
}
if (rsaType == RSAType.RSA2)
{
_hashAlgorithmName = HashAlgorithmName.SHA256;
}
if (rsaType == RSAType.MD5)
{
_hashAlgorithmName = HashAlgorithmName.MD5;
}
}
private static string RsaSign(string value, string key, Encoding encoding, RSAType type)
{
if (string.IsNullOrWhiteSpace(value) || string.IsNullOrWhiteSpace(key))
return string.Empty;
var rsa = new RSAHelper(type, encoding, key);
return rsa.Sign(value);
}
/// <summary>
/// 实例化RSAHelper
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
public RSAHelper(RSAType rsaType, Encoding encoding, string privateKey, string publicKey = null)
{
_encoding = encoding;
if (!string.IsNullOrEmpty(privateKey))
{
_privateKeyRsaProvider = DecodePemPrivateKey(privateKey);
}
if (!string.IsNullOrEmpty(publicKey))
{
_publicKeyRsaProvider = DecodePemPublicKey(publicKey);
}
#if NET45
if (rsaType == RSAType.RSA)
{
_sh = new SHA1CryptoServiceProvider();
}
else
{
_sh = new SHA256CryptoServiceProvider();
}
#endif
#if NETSTANDARD2_0
_hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
#endif
}
/// <summary>
/// 使用私钥签名
/// </summary>
/// <param name="data">原始数据</param>
/// <returns></returns>
public static byte[] RSASign(this byte[] dataBytes, byte[] privateKey, RSAType rsaType = RSAType.RSA2)
{
using (RSA rsa = CreateRsaFromPrivateKey(privateKey))
{
var encoding = Encoding.UTF8;
var hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
return(rsa.SignData(dataBytes, hashAlgorithmName, RSASignaturePadding.Pkcs1));
}
}
/// <summary>
/// 使用私钥签名
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
/// <param name="privateKey">私钥</param>
/// <param name="data">签名数据</param>
/// <param name="encoding">编码类型</param>
/// <returns></returns>
public static string Sign(RSAType rsaType, string privateKey, string data, Encoding encoding)
{
byte[] dataBytes = encoding.GetBytes(data);
var privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
var signatureBytes = privateKeyRsaProvider.SignData(dataBytes, rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
return(Convert.ToBase64String(signatureBytes));
}
/// <summary>
/// Rsa加密
/// </summary>
private static string RsaSign(string value, string key, Encoding encoding, RSAType type)
{
if (string.IsNullOrWhiteSpace(value) || string.IsNullOrWhiteSpace(key))
{
return(string.Empty);
}
var rsa = new RsaOpenSSLHelper(type, encoding, key);
return(rsa.Sign(value));
}
/// <summary>
/// 签名
/// </summary>
/// <param name="str">需要签名的字符串</param>
/// <param name="privateKey">私钥</param>
/// <param name="type"></param>
/// <returns></returns>
public static string RSATrySign(this string str, string privateKey, RSAType type = RSAType.RSA2)
{
try
{
return(RSASign(str, privateKey, type));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// RSA加密
/// </summary>
/// <param name="str">需要加密的内容</param>
/// <param name="publicKey">公钥</param>
/// <param name="type">类型（加密算法类型 RSA SHA1 长度不限制，推荐使用2048位以上;RSA2 SHA256 密钥长度至少为2048）</param>
/// <returns></returns>
public static string RSATryEncrypt(this string str, string publicKey, RSAType type = RSAType.RSA2)
{
try
{
return(RSAEncrypt(str, publicKey, type));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// 公钥加密
/// </summary>
/// <param name="value"></param>
/// <param name="key"></param>
/// <param name="encoding"></param>
/// <param name="type"></param>
/// <returns></returns>
public static string RsaEncrypt(string value, string key, Encoding encoding, RSAType type)
{
if (string.IsNullOrWhiteSpace(value) || string.IsNullOrWhiteSpace(key))
{
return(string.Empty);
}
var rsa = new RsaOpenSSLHelper(type, Encoding.UTF8, "", key);
return(rsa.Encrypt(value));
}
/// <summary>
/// 使用公钥验证签名
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
/// <param name="publicKey">公钥</param>
/// <param name="data">原始数据</param>
/// <param name="sign">签名</param>
/// <param name="encoding">编码类型</param>
/// <returns></returns>
public static bool Verify(RSAType rsaType, string publicKey, string data, string sign, Encoding encoding)
{
byte[] dataBytes = encoding.GetBytes(data);
byte[] signBytes = Convert.FromBase64String(sign);
var publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
var verify = publicKeyRsaProvider.VerifyData(dataBytes, signBytes, rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
return(verify);
}
/// <summary>
/// 使用指定公钥验证解密得到的明文是否符合签名
/// </summary>
/// <param name="source">解密得到的明文</param>
/// <param name="signData">明文签名字符串</param>
/// <param name="publicKey">公钥</param>
/// <param name="encoding">编码类型</param>
/// <param name="outType">输出类型</param>
/// <param name="rsaType">算法类型</param>
/// <param name="keyType">密钥类型</param>
/// <returns></returns>
public static bool VerifyData(string source, string signData, string publicKey, Encoding encoding = null,
OutType outType = OutType.Base64, RSAType rsaType = RSAType.RSA, RSAKeyType keyType = RSAKeyType.Xml)
{
if (encoding == null)
{
encoding = Encoding.UTF8;
}
byte[] sourceBytes = encoding.GetBytes(source);
byte[] signBytes = signData.GetEncryptBytes(outType);
return(VerifyData(sourceBytes, signBytes, publicKey, rsaType, keyType));
}
/// <summary>
/// 实例化RSAHelper
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
internal RsaHelper(RSAType rsaType, Encoding encoding, string privateKey, string publicKey = null)
{
_encoding = encoding;
if (!string.IsNullOrEmpty(privateKey))
{
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
}
if (!string.IsNullOrEmpty(publicKey))
{
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
}
_hashAlgorithmName = rsaType == RSAType.SHA1 ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
}
public RSA(RSAType rsaType, System.Text.Encoding encoding, string privateKey, string publicKey = null)
{
_encoding = encoding;
if (!string.IsNullOrEmpty(privateKey))
{
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
}
if (!string.IsNullOrEmpty(publicKey))
{
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
}
_hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
}
public RSAEncryptionProvider(RSAType rsaType, Encoding encoding, IEncryptionKeyProvider keyProvider)
{
_encoding = encoding;
if (!string.IsNullOrEmpty(keyProvider.PrivateKey))
{
_privateKeyRsaProvider = CreateProviderFromPrivateKey(keyProvider.PrivateKey);
}
if (!string.IsNullOrEmpty(keyProvider.PublicKey))
{
_publicKeyRsaProvider = CreateProviderFromPublicKey(keyProvider.PublicKey);
}
_hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
}
/// <summary>
/// 实例化RSAHelper
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
public RsaOpenSSLHelper(RSAType rsaType, Encoding encoding, string privateKey, string publicKey = null)
{
this.encoding = encoding;
if (!string.IsNullOrEmpty(privateKey))
{
privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
}
if (!string.IsNullOrEmpty(publicKey))
{
publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
}
hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
}
public RsaUtils(string key, CertificateType certificateType, RSAType rsaType, Encoding encoding)
{
this._hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
this._encoding = encoding;
switch (certificateType)
{
case CertificateType.PublicKey:
_rsaInstance = CreateRsaByPublicKey(key);
break;
case CertificateType.PrivateKey:
_rsaInstance = CreateRsaByPrivateKey(key);
break;
}
}
/// <summary>
/// 实例化RSAHelper
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
public RSAHelper(RSAType rsaType = RSAType.RSA2)
{
var rsakey = getkey();
_encoding = Encoding.UTF8;
if (!string.IsNullOrEmpty(rsakey.PrivateKey))
{
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(rsakey.PrivateKey);
}
if (!string.IsNullOrEmpty(rsakey.PublicKey))
{
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(rsakey.PublicKey);
}
_hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
}
/// <summary>
/// RSA解密
/// </summary>
/// <param name="content">密文</param>
/// <param name="rsaKey">公钥</param>
/// <returns>明文</returns>
public static string RSADecryByType(string content, string rsaKey, RSAType type)
{
try
{
MemoryStream bufferStream = new MemoryStream();
byte[] bytData = Convert.FromBase64String(content);
int inputLength = bytData.Length;
AsymmetricKeyParameter key;
if (type == RSAType.公钥)
{
key = PublicKeyFactory.CreateKey(Convert.FromBase64String(rsaKey));
}
else
{
key = PrivateKeyFactory.CreateKey(Convert.FromBase64String(rsaKey));
}
IBufferedCipher cipher = CipherUtilities.GetCipher("RSA/ECB/PKCS1Padding");
cipher.Init(false, key);
int offSet = 0;
byte[] cache;
int i = 0;
while (inputLength - offSet > 0)
{
if (inputLength - offSet > 128)
{
cache = cipher.DoFinal(bytData, offSet, 128);
}
else
{
cache = cipher.DoFinal(bytData, offSet, inputLength - offSet);
}
bufferStream.Write(cache, 0, cache.Length);
i++;
offSet = i * 128;
}
byte[] decryptedData = bufferStream.ToArray();
bufferStream.Close();
return(Encoding.UTF8.GetString(bufferStream.ToArray()));
}
catch (Exception e)
{
return(e.Message);
}
}
/// <summary>
/// 使用私钥签名
/// </summary>
/// <param name="data"></param>
/// <param name="privateKey"></param>
/// <param name="rsaType"></param>
/// <param name="charset"></param>
/// <returns></returns>
public static string Sign(string data, string privateKey, RSAType rsaType = RSAType.MD5, string charset = "utf-8")
{
if (string.IsNullOrEmpty(privateKey))
{
throw new Exception("Private key can't be null.");
}
byte[] bt = Encoding.GetEncoding(charset).GetBytes(data);
using (RSA rsa = CreateRsaProviderFromPrivateKey(privateKey))
{
if (rsa == null)
{
throw new Exception("Private key is error");
}
var signatureBytes = rsa.SignData(bt, DicAlgorithmName[rsaType], RSASignaturePadding.Pkcs1);
return(Convert.ToBase64String(signatureBytes));
}
}
/// <summary>
/// 实例化RSAHelper
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
/// <param name="appKey"></param>
/// <param name="splitStr"></param>
public RSAHelper(RSAType rsaType, Encoding encoding, string privateKey, string publicKey = null, string appKey = null, string splitStr = null)
{
_encoding = encoding;
if (!string.IsNullOrWhiteSpace(privateKey))
{
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
}
if (!string.IsNullOrWhiteSpace(publicKey))
{
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
}
if (!string.IsNullOrWhiteSpace(appKey))
{
_publicAppKeyRsaProvider = CreateRsaProviderFromPublicKey(appKey);
}
_hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
_splitStr = splitStr;
}
/// <summary>
/// 使用指定密钥对明文进行签名，返回明文签名的字符串
/// </summary>
/// <param name="source">要签名的明文字符串</param>
/// <param name="privateKey">私钥</param>
/// <param name="encoding">编码类型</param>
/// <param name="outType">输出类型</param>
/// <param name="rsaType">算法类型</param>
/// <param name="keyType">密钥类型</param>
/// <returns></returns>
public static string SignData(string source, string privateKey, Encoding encoding = null,
OutType outType = OutType.Base64, RSAType rsaType = RSAType.RSA,
RSAKeyType keyType = RSAKeyType.Xml)
{
if (encoding == null)
{
encoding = Encoding.UTF8;
}
var result = SignData(encoding.GetBytes(source), privateKey, rsaType, keyType);
if (outType == OutType.Base64)
{
return(Convert.ToBase64String(result));
}
return(result.ToHexString());
}
/// <summary>
/// 实例化RSAHelper
/// </summary>
/// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
public RSAEncrypt(RSAType rsaType, Encoding encoding, string privateKeyFile, string publicKeyFile = null)
{
//密匙不能带BEGIN
_encoding = encoding;
if (!string.IsNullOrEmpty(privateKeyFile))
{
string sPrivateKeyPEM = File.ReadAllText(privateKeyFile);
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(sPrivateKeyPEM);
}
if (!string.IsNullOrEmpty(publicKeyFile))
{
string sPublicKeyPEM = File.ReadAllText(publicKeyFile);
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(sPublicKeyPEM);
}
_hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
}
/// <summary>
/// 使用公钥验证签名
/// </summary>
/// <param name="data">原始数据</param>
/// <param name="sign">签名</param>
/// <returns></returns>
public static bool CheckSign(string data, string sign, string publicKey, RSAType rsaType = RSAType.MD5, string charset = "utf-8")
{
if (string.IsNullOrEmpty(publicKey))
{
throw new Exception("Public key can't be null.");
}
byte[] bt = Encoding.GetEncoding(charset).GetBytes(data);
byte[] signBytes = Convert.FromBase64String(sign);
using (RSA rsa = CreateRsaProviderFromPublicKey(publicKey))
{
if (rsa == null)
{
throw new Exception("Public key is error");
}
var verify = rsa.VerifyData(bt, signBytes, DicAlgorithmName[rsaType], RSASignaturePadding.Pkcs1);
return(verify);
}
}
/// <summary>
/// 实例化RSASystemHelper
/// </summary>
/// <param name="rsaType">加密算法类型</param>
/// <param name="encoding">编码类型</param>
/// <param name="privateKey">私钥</param>
/// <param name="publicKey">公钥</param>
public RSASystemHelper(RSAType rsaType, Encoding encoding, string privateKey = null, string publicKey = null)
{
_encoding = encoding ?? Encoding.UTF8;
if (!string.IsNullOrEmpty(privateKey))
{
IsBase64 = !JudgeBinary.IsHexadecimal(privateKey);
_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
}
if (!string.IsNullOrEmpty(publicKey))
{
IsBase64 = !JudgeBinary.IsHexadecimal(publicKey);
_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
}
switch (rsaType)
{
case RSAType.MD5:
_hashAlgorithmName = HashAlgorithmName.MD5;
break;
case RSAType.SHA1:
_hashAlgorithmName = HashAlgorithmName.SHA1;
break;
case RSAType.SHA256:
_hashAlgorithmName = HashAlgorithmName.SHA256;
break;
case RSAType.SHA384:
_hashAlgorithmName = HashAlgorithmName.SHA384;
break;
case RSAType.SHA512:
_hashAlgorithmName = HashAlgorithmName.SHA512;
break;
default:
_hashAlgorithmName = HashAlgorithmName.MD5;
break;
}
}
/// <summary>
/// RSA加密
/// </summary>
/// <param name="content">加密明文</param>
/// <param name="rsaKey">公钥</param>
/// <returns>返回密文</returns>
public static string RSAEncryByType(string content, string rsaKey, RSAType type)
{
AsymmetricKeyParameter key;
if (type == RSAType.公钥)
{
key = PublicKeyFactory.CreateKey(Convert.FromBase64String(rsaKey));
}
else
{
key = PrivateKeyFactory.CreateKey(Convert.FromBase64String(rsaKey));
}
IBufferedCipher c = CipherUtilities.GetCipher("RSA/ECB/PKCS1Padding");
//私钥加密
c.Init(true, key);
byte[] byteData = Encoding.UTF8.GetBytes(content);
byteData = c.DoFinal(byteData, 0, byteData.Length);
return(Convert.ToBase64String(byteData));
}
/// <summary>
/// 使用指定私钥对明文进行签名，返回明文签名的字节数组
/// </summary>
/// <param name="source">要签名的明文字节数组</param>
/// <param name="privateKey">私钥</param>
/// <param name="rsaType">算法类型</param>
/// <param name="keyType">密钥类型</param>
/// <returns></returns>
public static byte[] SignData(byte[] source, string privateKey, RSAType rsaType = RSAType.RSA, RSAKeyType keyType = RSAKeyType.Xml)
{
using (var rsa = RSA.Create())
{
if (keyType == RSAKeyType.Xml)
{
rsa.FromExtXmlString(privateKey);
}
else if (keyType == RSAKeyType.Base64)
{
rsa.FromBase64StringByPrivateKey(privateKey);
}
else
{
rsa.FromJsonString(privateKey);
}
return(rsa.SignData(source, rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256,
RSASignaturePadding.Pkcs1));
}
}
/// <summary>
/// Rsa验签
/// </summary>
private static bool RsaVerify(string value, string publicKey, string sign, Encoding encoding, RSAType type)
{
if (string.IsNullOrWhiteSpace(value) || string.IsNullOrWhiteSpace(publicKey) || string.IsNullOrWhiteSpace(sign))
{
return(false);
}
var rsa = new RsaHelper(type, encoding, publicKey: publicKey);
return(rsa.Verify(value, sign));
}
