RSA加密解密

项目场景：

Unity通过C#自带的RSA对登录密码进行加密

注意：RSA加密需要XML公钥，我们首先要吧PEM格式转换成XML格式（C#RSA只支持XML格式）

将BouncyCastle.Crypto.dll导入到Unity工程

链接：https://pan.baidu.com/s/1OpW3l2YqQCWaQaQQrDE1aw 
提取码：9gen

---

解决方案：

using UnityEngine;
using System.Collections;
using System.Security.Cryptography;
using System.Text;
using System;
using System.Linq;
using XLua;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Security;

[LuaCallCSharp]
public class RSAPro : MonoBehaviour
{
    string publickey= "-------------------";
    //string privatekey = "-------------------------";
    string RSAed;
    public string mingwen;
    //RSACryptoServiceProvider rsa;
    void Start()
    {
        //rsa = new RSACryptoServiceProvider();
        //publickey = rsa.ToXmlString(false);
        //privatekey = rsa.ToXmlString(true);
        //Debug.Log("公钥：" + publickey);
        //Debug.Log("私钥：" + privatekey);
    }

    void Update()
    {
        //if (Input.GetMouseButtonDown(0))
        //{
        //    RSAed = RSAEncrypt(publickey, mingwen);
        //    Debug.Log("加密后：" + RSAed);
        //    Debug.Log("解密后：" + RSADecrypt(privatekey, RSAed));

        //    UnicodeEncoding ByteConverter = new UnicodeEncoding();
        //    byte[] dataToEncrypt = ByteConverter.GetBytes("ABC");

        //    //RAS数字签名  
        //    RSAParameters Key = rsa.ExportParameters(true);
        //    byte[] signedData = HashAndSignBytes(dataToEncrypt, Key);

        //    if (VerifySignedHash(dataToEncrypt, signedData, Key))
        //    {
        //        Debug.Log("数据验证通过");
        //    }
        //    else
        //    {
        //        Debug.Log("没有通过");
        //    }
        //}

        if (Input.GetKeyDown(KeyCode.P))
        {
            //Debug.Log("加密后：" + Test("123456"));
            RSAed = RSAEncrypt(publickey, "123456");
            Debug.Log("加密后：" + RSAed);
            //Debug.Log("解密后：" + RSADecrypt(privatekey, RSAed));
        }

    }
    /// <summary>    
    /// RSA公钥pem-->XML格式转换， 
    /// </summary>    
    /// <param name="publicKey">pem公钥</param>    
    /// <returns></returns>    
    public string RSAPublicKey(string publicKey)
    {
        RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));
        string XML = string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
        Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
        Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));
        return XML;
    }
    /// <summary>
    /// 加密
    /// </summary>
    /// <param name="publickey">公钥</param>
    /// <param name="content">所加密的内容</param>
    /// <returns>加密后的内容</returns>
    public string RSAEncrypt(string publickey, string content)
    {
        RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
        byte[] cipherbytes;
        rsa.FromXmlString(RSAPublicKey(publickey));
        cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(content), false);
        return Convert.ToBase64String(cipherbytes);

    }
    public string Test(string s)
    {
        RSAed = RSAEncrypt(publickey, s);
        return RSAed;
    }
    /// <summary>
    /// 私钥转XML
    /// </summary>
    /// <param name="privateJavaKey"></param>
    /// <returns></returns>
    public static string ConvertToXmlPrivateKey(string privateJavaKey)
    {
        RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateJavaKey));
        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>
    /// 解密
    /// </summary>
    /// <param name="privatekey">私钥</param>
    /// <param name="content">加密后的内容</param>
    /// <returns>解密后的内容</returns>
    public string RSADecrypt(string privatekey, string content)
    {
        RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
        byte[] cipherbytes;
        rsa.FromXmlString(ConvertToXmlPrivateKey(privatekey));
        cipherbytes = rsa.Decrypt(Convert.FromBase64String(content), false);
        return Encoding.UTF8.GetString(cipherbytes);
    }

    /// <summary>
    /// 签名
    /// </summary>
    /// <param name="DataToSign"></param>
    /// <param name="Key"></param>
    /// <returns></returns>
    static byte[] HashAndSignBytes(byte[] DataToSign, RSAParameters Key)
    {
        try
        {
            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
            RSA.ImportParameters(Key);
            return RSA.SignData(DataToSign, new SHA1CryptoServiceProvider());
        }
        catch
        {
            return null;
        }
    }


    /// <summary>
    /// 验证签名
    /// </summary>
    /// <param name="DataToVerify"></param>
    /// <param name="SignedData"></param>
    /// <param name="Key"></param>
    /// <returns></returns>
    static bool VerifySignedHash(byte[] DataToVerify, byte[] SignedData, RSAParameters Key)
    {
        try
        {
            RSACryptoServiceProvider RSAalg = new RSACryptoServiceProvider();
            RSAalg.ImportParameters(Key);
            return RSAalg.VerifyData(DataToVerify, new SHA1CryptoServiceProvider(), SignedData);
        }
        catch
        {
            return false;
        }
    }
}