C#加密：RSA加密解密

public class RSAHelper
{
    /// <summary>
    /// 使用RSA实现加密
    /// </summary>
    /// <param name="data">加密数据</param>
    /// <returns></returns>
    public string RSAEncrypt(string data)
    {
        //C#默认只能使用[公钥]进行加密(想使用[公钥解密]可使用第三方组件BouncyCastle来实现)
        string publicKeyPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PublicKey.key");
        string publicKey = File.ReadAllText(publicKeyPath);
        //创建RSA对象并载入[公钥]
        RSACryptoServiceProvider rsaPublic = new RSACryptoServiceProvider();
        rsaPublic.FromXmlString(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>
    /// <returns></returns>
    public string RSADecrypt(string data)
    {
        //C#默认只能使用[私钥]进行解密(想使用[私钥加密]可使用第三方组件BouncyCastle来实现)
        string privateKeyPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PrivateKey.key");
        string privateKey = File.ReadAllText(privateKeyPath);
        //创建RSA对象并载入[私钥]
        RSACryptoServiceProvider rsaPrivate = new RSACryptoServiceProvider();
        rsaPrivate.FromXmlString(privateKey);
        //对数据进行解密
        byte[] privateValue = rsaPrivate.Decrypt(Convert.FromBase64String(data), false);//使用Base64将string转换为byte
        string privateStr = Encoding.UTF8.GetString(privateValue);
        return privateStr;
    }
 
 
    /// <summary>
    /// 创建RSA公钥私钥
    /// </summary>
    public void CreateRSAKey()
    {
        //设置[公钥私钥]文件路径
        string privateKeyPathNet = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PrivateKey.key");
        string publicKeyPathNet = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PublicKey.key");
        string privateKeyPathJava = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PrivateKeyJava.key");
        string publicKeyPathJava = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PublicKeyJava.key");
        //创建RSA对象
        RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(1024);
        //生成RSA[公钥私钥]
        string privateKeyNet = rsa.ToXmlString(true);
        string publicKeyNet = rsa.ToXmlString(false);
 
        string privateKeyJava = RSAKeyConvert.RSAPrivateKeyDotNet2Java(privateKeyNet);
        string publicKeyJava = RSAKeyConvert.RSAPublicKeyDotNet2Java(publicKeyNet);
        //将密钥写入指定路径
        File.WriteAllText(privateKeyPathNet, privateKeyNet);//文件内包含公钥和私钥
        File.WriteAllText(publicKeyPathNet, publicKeyNet);//文件内只包含公钥
 
        File.WriteAllText(privateKeyPathJava, privateKeyJava);//文件内包含公钥和私钥
        File.WriteAllText(publicKeyPathJava, publicKeyJava);//文件内只包含公钥
    }
}

public class RSAKeyConvert
{
    /// <summary>
    /// RSA私钥格式转换，java->.net
    /// </summary>
    /// <param name="privateKey">java生成的RSA私钥</param>
    /// <returns></returns>
    public static string RSAPrivateKeyJava2DotNet(string privateKey)
    {
        RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));
 
        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>",
            Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));
    }
 
    /// <summary>
    /// RSA私钥格式转换，.net->java
    /// </summary>
    /// <param name="privateKey">.net生成的私钥</param>
    /// <returns></returns>
    public static string RSAPrivateKeyDotNet2Java(string privateKey)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(privateKey);
        BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
        BigInteger exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
        BigInteger d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));
        BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));
        BigInteger q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));
        BigInteger dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));
        BigInteger dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));
        BigInteger qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));
 
        RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);
 
        PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
        byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
        return Convert.ToBase64String(serializedPrivateBytes);
    }
 
    /// <summary>
    /// RSA公钥格式转换，java->.net
    /// </summary>
    /// <param name="publicKey">java生成的公钥</param>
    /// <returns></returns>
    public static string RSAPublicKeyJava2DotNet(string publicKey)
    {
        RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));
        return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
            Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
            Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));
    }
 
    /// <summary>
    /// RSA公钥格式转换，.net->java
    /// </summary>
    /// <param name="publicKey">.net生成的公钥</param>
    /// <returns></returns>
    public static string RSAPublicKeyDotNet2Java(string publicKey)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(publicKey);
        BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
        BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
        RsaKeyParameters pub = new RsaKeyParameters(false, m, p);
 
        SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub);
        byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();
        return Convert.ToBase64String(serializedPublicBytes);
    }
}