C# RSA加密代码

/// <summary>
/// rsa帮助类
/// </summary>
public class RSAEncryptHelper
{
/// <summary>
/// 创建RSA公钥私钥
/// </summary>
public static void CreateRSAKey()
{
//设置[公钥私钥]文件路径
string privateKeyPath = @"d:\\PrivateKey.xml";
string publicKeyPath = @"d:\\PublicKey.xml";
var rsa = RSA.Create();
//创建RSA对象
//RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
//生成RSA[公钥私钥]
string privateKey = rsa.ToXmlStringExtensions(true);
string publicKey = rsa.ToXmlStringExtensions(false);
//将密钥写入指定路径
File.WriteAllText(privateKeyPath, privateKey);//文件内包含公钥和私钥
File.WriteAllText(publicKeyPath, publicKey);//文件内只包含公钥
}

#region rsa加解密
/// <summary>
/// 使用RSA实现加密（公钥加密）
/// </summary>
/// <param name="data">加密数据</param>
/// <param name="publicKey">公钥</param>
/// <param name="isHandleKey">是否需要处理公钥</param>
/// <returns></returns>
public static string RSAEncrypt(string data, string publicKey,bool isHandleKey = false)
{
if(isHandleKey)
{
publicKey = SHA256WithRSAHelper.RSAPublicKeyJava2DotNet(publicKey);
}

//C#默认只能使用[公钥]进行加密(想使用[公钥解密]可使用第三方组件BouncyCastle来实现)
//string publicKeyPath = @"d:\\PublicKey.xml";
//string publicKey = File.ReadAllText(publicKeyPath);
//创建RSA对象并载入[公钥]
RSACryptoServiceProvider rsaPublic = new RSACryptoServiceProvider();
rsaPublic.FromXmlStringExtensions(publicKey);
//对数据进行加密
byte[] publicValue = rsaPublic.Encrypt(Encoding.UTF8.GetBytes(data), false);
string publicStr = Convert.ToBase64String(publicValue);//使用Base64将byte转换为string
return publicStr;
}

/// <summary>
/// 使用RSA实现解密（私钥解密）
/// </summary>
/// <param name="data">解密数据</param>
/// <param name="privateKey">私钥</param>
/// <param name="isHandleKey">是否需要处理私钥</param>
/// <returns></returns>
public static string RSADecrypt(string data, string privateKey, bool isHandleKey = false)
{
if (isHandleKey)
{
privateKey = SHA256WithRSAHelper.RSAPrivateKeyJava2DotNet(privateKey);
}

//C#默认只能使用[私钥]进行解密(想使用[私钥加密]可使用第三方组件BouncyCastle来实现)
//string privateKeyPath = @"d:\\PrivateKey.xml";
//string privateKey = File.ReadAllText(privateKeyPath);
//创建RSA对象并载入[私钥]
RSACryptoServiceProvider rsaPrivate = new RSACryptoServiceProvider();
rsaPrivate.FromXmlStringExtensions(privateKey);

//对数据进行解密
byte[] privateValue = rsaPrivate.Decrypt(Convert.FromBase64String(data), false);//使用Base64将string转换为byte
string privateStr = Encoding.UTF8.GetString(privateValue);
return privateStr;
}
#endregion

#region 证书rsa加解密
/// <summary>
/// 证书RSA实现加密（公钥加密）
/// </summary>
/// <param name="data">加密数据</param>
/// <param name="certPath">证书路径</param>
/// <param name="certPassword">证书密码</param>
/// <returns></returns>
public static string CertRSAEncrypt(string data, string certPath, string certPassword)
{
//证书
var cert = CertificateHelper.GetCertHelper(certPath, certPassword);
//创建RSA对象并载入[公钥]
RSACryptoServiceProvider rsaPublic = cert.PublicKey.Key as RSACryptoServiceProvider;
//对数据进行加密
byte[] publicValue = rsaPublic.Encrypt(Encoding.UTF8.GetBytes(data), false);
string publicStr = Convert.ToBase64String(publicValue);//使用Base64将byte转换为string
return publicStr;
}

/// <summary>
/// 使用RSA实现解密（私钥解密）
/// </summary>
/// <param name="data">解密数据</param>
/// <param name="certPath">证书路径</param>
/// <param name="certPassword">证书密码</param>
/// <returns></returns>
public static string CertRSADecrypt(string data, string certPath, string certPassword)
{
//证书
var cert = CertificateHelper.GetCertHelper(certPath, certPassword);
//创建RSA对象并载入[私钥]
RSACryptoServiceProvider rsaPrivate = cert.PrivateKey as RSACryptoServiceProvider;
//对数据进行解密
byte[] privateValue = rsaPrivate.Decrypt(Convert.FromBase64String(data), false);//使用Base64将string转换为byte
string privateStr = Encoding.UTF8.GetString(privateValue);
return privateStr;
}
#endregion

}

/// <summary>
/// System.Security.Cryptography.RSA 扩展方法
/// </summary>
internal static class RSAExtensions
{
// 处理 下面两种方式都会出现的 Operation is not supported on this platform 异常
// RSA.Create().FromXmlString(privateKey)
// new RSACryptoServiceProvider().FromXmlString(privateKey)

/// <summary>
/// 扩展FromXmlString
/// </summary>
/// <param name="rsa"></param>
/// <param name="xmlString"></param>
public static void FromXmlStringExtensions(this RSA rsa, string xmlString)
{
RSAParameters parameters = new RSAParameters();

XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xmlString);

if (xmlDoc.DocumentElement.Name.Equals("RSAKeyValue"))
{
foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)
{
switch (node.Name)
{
case "Modulus": parameters.Modulus = (string.IsNullOrEmpty(node.InnerText) ? null : Convert.FromBase64String(node.InnerText)); break;
case "Exponent": parameters.Exponent = (string.IsNullOrEmpty(node.InnerText) ? null : Convert.FromBase64String(node.InnerText)); break;
case "P": parameters.P = (string.IsNullOrEmpty(node.InnerText) ? null : Convert.FromBase64String(node.InnerText)); break;
case "Q": parameters.Q = (string.IsNullOrEmpty(node.InnerText) ? null : Convert.FromBase64String(node.InnerText)); break;
case "DP": parameters.DP = (string.IsNullOrEmpty(node.InnerText) ? null : Convert.FromBase64String(node.InnerText)); break;
case "DQ": parameters.DQ = (string.IsNullOrEmpty(node.InnerText) ? null : Convert.FromBase64String(node.InnerText)); break;
case "InverseQ": parameters.InverseQ = (string.IsNullOrEmpty(node.InnerText) ? null : Convert.FromBase64String(node.InnerText)); break;
case "D": parameters.D = (string.IsNullOrEmpty(node.InnerText) ? null : Convert.FromBase64String(node.InnerText)); break;
}
}
}
else
{
throw new Exception("Invalid XML RSA key.");
}

rsa.ImportParameters(parameters);
}

/// <summary>
/// 扩展ToXmlString
/// </summary>
/// <param name="rsa"></param>
/// <param name="includePrivateParameters"></param>
/// <returns></returns>
public static string ToXmlStringExtensions(this RSA rsa, bool includePrivateParameters)
{
RSAParameters parameters = rsa.ExportParameters(includePrivateParameters);

return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent><P>{2}</P><Q>{3}</Q><DP>{4}</DP><DQ>{5}</DQ><InverseQ>{6}</InverseQ><D>{7}</D></RSAKeyValue>",
parameters.Modulus != null ? Convert.ToBase64String(parameters.Modulus) : null,
parameters.Exponent != null ? Convert.ToBase64String(parameters.Exponent) : null,
parameters.P != null ? Convert.ToBase64String(parameters.P) : null,
parameters.Q != null ? Convert.ToBase64String(parameters.Q) : null,
parameters.DP != null ? Convert.ToBase64String(parameters.DP) : null,
parameters.DQ != null ? Convert.ToBase64String(parameters.DQ) : null,
parameters.InverseQ != null ? Convert.ToBase64String(parameters.InverseQ) : null,
parameters.D != null ? Convert.ToBase64String(parameters.D) : null);
}