ras私钥c#转java_C#和JAVA的RSA密钥、公钥转换

C#的秘钥跟JAVA的密钥区别

RSA对于程序本身是没有区别的，其格式都是相同的。对于不同的程序来说，存储使用的语法(包装的类)会有所不同。

RSA语法和语法标准有很多，大的类型大概分为ASN.1、PKCS、X.509。

RSA语法介绍

ASN.1、PKCS是最初的，也是最主要的RSA公钥和私钥的语法标准，被RSA Lab所维护。

ASN.1、PKCS#1都定义了公钥和私钥的类型——序列化的数字。为了下一个层次的抽象(适当的包装)，现在一般使用的组合是：PKCS#8的私钥，X.509的公钥 。

PKCS语法主要用于私钥，其内部标准目前有10种。目前JAVA普遍使用的是PKCS#8，用作私钥格式。

X.509语法主要用于公钥，广泛使用于web浏览器和SLL。

3种语法标准的公私钥可以实现相互转化，其核心为ASN1语法中的整数值(modulus，PublicExponent，privateExponent )，其余的数值都可以经过计算后得出。

.NET使用的是标准的RSA格式，然后将其中的数字base64编码后，生成XML进行存储。

java中使用的是PKCS#8,、X.509的公私钥语法，存储的都是相应的JAVA类自动生成的base64字符串。

由于存储格式的区别，在相互转换、读取的时候，需要理解RSA相关的知识，才能正确使用类来转换。

密钥格式

java密钥：

私钥：

MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAKSZSSEdPhv77O5ocnLNGXeQ21qJDArC1+yId+9/pY5bXkZk5vCB49EpfMwNukLv6AJqofThZPNOs1t015fdEYIUnkIc2QVxRwa0xTeFP

6N8D4WQXRWs4fNG27JK5kP45s+9KlJtx5hs7G97aMczehIWpHaO6j9inOmjlU8l62KZAgMBAAECgYEAmK3TRtMwRJb33OGnn9OeFumYfy92qxi3X6Hq1o6qDBW2qkd4bImfv+ni6AinyOVuaadt2Y+lq4

dKGcCVJzoZvPm1VKxD2y7xKa8/vEbPRiRTt0qnPq9T7UJkpDsiXf/zOMfWdjc3uA1bPnQ65RWHSJ7zAE+Gd7xnyCE5MEyijLECQQDVYqQWDqOVLZ5lJUuIfUIrhv26GvuoTX8v60+opCz4/Mdfh6JlefI

CVD6SAaYvufXBHVFY26JicNlR62ZOiBoNAkEAxXhsuEnNJNQcQHEVTPZoulbMbTV1VZIDQ1zjG8fvu8sv6IBYcR5+EsC8n3/6RkW8/iCJDzxE++VHzhoSQSoDvQJBAM6/63J/rpndAIrJ7vyJOPLJsc9/U

3SH2gMJAT7KC9UXvuldlsixtf3xuEpplKbLjEUXbfklnZm586a+6XqPvoUCQDFotltOLARBBmihYuEE7qNhQHk63QbyJ9rdDP5Qgo2Mg4o7QuXa6VSr4QZPsUGQBX/YiDLFs8ULU3IgV9zyNEkCQADAYR8

DctYzg0eBGdcOrDA5Szc62pYrS2wk89wUxyL4FyDL3omkVMKvtu5tccy7Xht2ikJZRqefZ3dS7ASm8/4=

公钥：

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCkmUkhHT4b++zuaHJyzRl3kNtaiQwKwtfsiHfvf6WOW15GZObwgePRKXzMDbpC7+gCaqH04WTzTrNbdNeX3RGCFJ5CHNkFcUcGtMU3hT+jfA+FkF0VrO

HzRtuySuZD+ObPvSpSbceYbOxve2jHM3oSFqR2juo/Ypzpo5VPJetimQIDAQAB

c#密钥：

私钥：

pJlJIR0+G/vs7mhycs0Zd5DbWokMCsLX7Ih373+ljlteRmTm8IHj0Sl8zA26Qu/oAmqh9OFk806zW3TXl90RghSeQhzZBXFHBrTFN4U/o3wPhZBdFazh80bbskrmQ/jmz70qUm3HmGzsb3tox

zN6Ehakdo7qP2Kc6aOVTyXrYpk=

AQAB

1WKkFg6jlS2eZSVLiH1CK4b9uhr7qE1/L+tPqKQs+PzHX4eiZXnyAlQ+kgGmL7n1wR1RWNuiYnDZUetmTogaDQ==

xXhsuEnNJNQcQHEVTPZoulbMbTV1VZIDQ1zjG8fvu8sv6IBYcR5+EsC8n3/6RkW8/iCJDzxE++VHzhoSQSoDvQ==

zr/rcn+umd0Aisnu/Ik48smxz39TdIfaAwkBPsoL1Re+6V2WyLG1/fG4SmmUpsuMRRdt+SWdmbnzpr7peo++hQ==

MWi2W04sBEEGaKFi4QTuo2FAeTrdBvIn2t0M/lCCjYyDijtC5drpVKvhBk+xQZAFf9iIMsWzxQtTciBX3PI0SQ==

wGEfA3LWM4NHgRnXDqwwOUs3OtqWK0tsJPPcFMci+Bcgy96JpFTCr7bubXHMu14bdopCWUann2d3UuwEpvP+

mK3TRtMwRJb33OGnn9OeFumYfy92qxi3X6Hq1o6qDBW2qkd4bImfv+ni6AinyOVuaadt2Y+lq4dKGcCVJzoZvPm1VKxD2y7xKa8/vEbPRiRTt0qnPq9T7UJkpDsiXf/zOMfWdjc3uA1bPnQ65RWHS

J7zAE+Gd7xnyCE5MEyijLE=

公钥：

pJlJIR0+G/vs7mhycs0Zd5DbWokMCsLX7Ih373+ljlteRmTm8IHj0Sl8zA26Qu/oAmqh9OFk806zW3TXl90RghSeQhzZBXFHBrTFN4U/o3wPhZBdFazh80bbskrmQ/jmz70qUm3HmGzsb3tox

zN6Ehakdo7qP2Kc6aOVTyXrYpk=

AQAB

C#转JAVA(C#代码)

C#中的公私钥使用XML字符串进行存储，读取时直接读入字符串即可。

由于C#使用的是标准的RSA格式，因此JAVA的RSAPublicKeySpec、RSAPrivateKeySpec配置类的核心参数(modulus，PublicExponent，privateExponent )都可以从对应XML中的节点值(Modulus-modulus 、Exponent-PublicExponent 、D-privateExponent )base64解码后获取。然后将其传入JAVA配置类中，然后根据配置类生成相应的RSA公私钥。

手动转换

void Convert()

{

//公钥

byte[] m = Base64.decodeBase64("mX/9zl8rflH5pLaP5P1Qd/9wXwNBSx7OpLlYDnGr7wD0njiDfPSUkgf9oF5NcvZwl24qdJ1SLmrgUtnr+yeXBNZNKaan1xXKISHdlHvbW5G8nJCJW6CuaHMkVw3Y7kwaIIlUdv09vxfjj0AoabttjbtF1kqETzbQ6fK3EN6sY5U=");

byte[] e = Base64.decodeBase64("AQAB");

BigInteger b1 = new BigInteger(1, m);

BigInteger b2 = new BigInteger(1, e);

//私钥

byte[] m1 = Base64.decodeBase64("3RgqP5YOYUXft8YOlDphyaCoof27MSfTD2eVCFVXB5hatrls1fSUcmUuWuGV970sS6KQZZtyWHQ5970sCzKFlq82He8Uoe0JM3axBvd6PbSGjulUJr62qNW5hgkIEfxSRYl8AQsbbusFtks4obfepsfE02cLmmZepnZAdIOWifE=");

byte[] e1 = Base64.decodeBase64("QcSZdLbHakolxX4GAjPnuNmwsBdRIsss7o0qeQMh02GPwoEgDfkmW20bv+8Q9FPypEEkYQU/m25ffAFq453QvLegYYi8OvWN+dvgchQRdeb22d+s6xYGGN9DRcPFRE48INde8FBHf/lzVgToV75h1H7g+jB4hLmLeuIuHsB43/0=");

BigInteger b11 = new BigInteger(1, m1);

BigInteger b21 = new BigInteger(1, e1);

//公钥

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);

RSAPublicKey pubKey = (RSAPublicKey) keyFactory.generatePublic(keySpec);

//私钥

RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(b11, b21);

RSAPrivateKey priKey = (RSAPrivateKey) keyFactory.generatePrivate(priKeySpec);

}

BouncyCastle Crypto转换

格式转换要用到一个开源加密库Bouncy Castle Crypto APIs，

using System;

using System.Xml;

using Org.BouncyCastle.Asn1.Pkcs;

using Org.BouncyCastle.Asn1.X509;

using Org.BouncyCastle.Crypto.Parameters;

using Org.BouncyCastle.Math;

using Org.BouncyCastle.Pkcs;

using Org.BouncyCastle.Security;

using Org.BouncyCastle.X509;

/// 

/// RSA密钥格式转换

/// 

public class RSAKeyConvert

{

/// 

/// RSA私钥格式转换，java->.net

/// 

/// java生成的RSA私钥

/// 

public static string RSAPrivateKeyJava2DotNet(string privateKey)

{

RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));

return string.Format("{0}{1}

{2}

{3}{4}{5}{6}{7}",

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()));

}

/// 

/// RSA私钥格式转换，.net->java

/// 

/// .net生成的私钥

/// 

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);

}

/// 

/// RSA公钥格式转换，java->.net

/// 

/// java生成的公钥

/// 

public static string RSAPublicKeyJava2DotNet(string publicKey)

{

RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));

return string.Format("{0}{1}",

Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),

Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));

}

/// 

/// RSA公钥格式转换，.net->java

/// 

/// .net生成的公钥

/// 

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);

}

}

JAVA转C#(java代码)

JAVA中的公私钥使用base64进行存储，解码成字节数组后，首先需要生成相应的配置对象(PKCS#8,、X.509 )，根据配置对象生成RSA公私钥。

私钥

C#使用的是标准的RSA格式，PKCS#1语法中包含了标准RSA格式私钥中的所有整数值。配置对象需要生成PKCS#1语法的RSA对象(RSAPrivateCrtKey)，获取对象属性，自行构造私钥XML。

就算不会JAVA的新手都可以转换的，只需要把以下的代码添加进eclipse中就可以了，具体的怎么建java工程就自己去查一下。

把一对密钥转成C#中格式的密钥在JAVA中的转换代码如下：

package com;

import java.security.KeyFactory;

import java.security.PublicKey;

import java.security.interfaces.RSAPrivateCrtKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;

public class test {

public static void main(String[] args) {

String tes = "MIICeQIBADANBgkqhkiG9w0BAQEFAASCAmMwggJfAgEAAoGBAL8z2QlXCL6w7rvY0Gbl8ARtQSXY+pEW5hlUHlmspqHt4k8/SkoF796gDqk4yyOcoWhkZWLPPugK35Mn7V+m5Jyfu8C0gVKOfWOA8A0T4hxV2ThAoMUq7QtB2K6s9AoumrxDfAkMBbsXEHYwfD/hxr/3DQ3lUvSFB6BnhiHEOyzpAgMBAAECgYEAol/9qRjorEjF9XEjSr9rHddKxEGIST8RGeF+BNnCiTHkRziQdlykYIO876jzmsKhsG3STB+EZLsXM3ls9RZefcsPF5mLOCSOCow3DikfCtAy4hntsU9JwpuYE0V4A+Sgfd24fatqbu+JxE2nvpSbAPczDOgBFPNfYBkhMiuZ/iECQQDzUeq7lFcIE4uWhRGveVFjNAGuSsW+q9GOwO7tS5YwuAIQ2M+XgYGRFo8xMC6V/9SfqJtmSU1zk72pMlYufIqHAkEAySqkcKbWuobq5I9KSQISq2qCuGKtj/iUFho4PCD1YxhnQ7gcHA4OpS1dRFjtXJYQPTX9be+mmypsCFIyofE5DwJBAPGZ20wahTh9v9Lbmq3z9n5ce3bGxAcJsHDg3d09eooxi8uSnL5BV5frII+k2f0TI9rMnlE4Y/FpN5+zXaOXAi0CQQCs3Aqfjo23jJWtPv/LSo+2YnjfblPMAgNmFrO532xc8axSgZMN/HpTL28UewHD7GMZ5hnWbPcSIFrir5c4luq7AkEAi90WdnZVPxtSTqkkLYbnh4Ro2WhdwRjkfyBxBZZx8hfaM6MfLPi3A0rw9DPOSB4M/BMchtEh3bXuI7bue2tG+A==";

byte[] temp = b64decode(tes);

String ver = getRSAPrivateKeyAsNetFormat(temp);// 转换私钥

String tes1 = "MIGfMA0GCSqGSIb4DQEBAQUAA4GNADCBiQKBgQC/M9kJVwi+sO672NBm5fAEbUEl2PqRFuYZVB5ZrKah7eJPP0pKBe/eoA6pOMsjnKFoZGVizz7oCt+TJ+1fpuScn7vAtIFSjn1jgPANE+IcVdk4QKDFKu0LQdiurPQKLpq8Q3wJDAW7FxB2MHw/4ca/9w0N5VL0hQegZ4YhxDss6QIDAQAB";

byte[] temp1 = b64decode(tes1);

String ver1 = getRSAPublicKeyAsNetFormat(temp1);// 转换公钥

System.out.println(ver);

System.out.println(ver1);

}

private static String getRSAPrivateKeyAsNetFormat(byte[] encodedPrivkey) {

try {

StringBuffer buff = new StringBuffer(1024);

PKCS8EncodedKeySpec pvkKeySpec = new PKCS8EncodedKeySpec(

encodedPrivkey);

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

RSAPrivateCrtKey pvkKey = (RSAPrivateCrtKey) keyFactory

.generatePrivate(pvkKeySpec);

buff.append("");

buff.append(""

+ b64encode(removeMSZero(pvkKey.getModulus()

.toByteArray())) + "");

buff.append(""

+ b64encode(removeMSZero(pvkKey.getPublicExponent()

.toByteArray())) + "");

buff.append("

"

+ b64encode(removeMSZero(pvkKey.getPrimeP().toByteArray()))

+ "

");

buff.append(""

+ b64encode(removeMSZero(pvkKey.getPrimeQ().toByteArray()))

+ "");

buff.append(""

+ b64encode(removeMSZero(pvkKey.getPrimeExponentP()

.toByteArray())) + "");

buff.append(""

+ b64encode(removeMSZero(pvkKey.getPrimeExponentQ()

.toByteArray())) + "");

buff.append(""

+ b64encode(removeMSZero(pvkKey.getCrtCoefficient()

.toByteArray())) + "");

buff.append(""

+ b64encode(removeMSZero(pvkKey.getPrivateExponent()

.toByteArray())) + "");

buff.append("");

return buff.toString().replaceAll("[ \t\n\r]", "");

} catch (Exception e) {

System.err.println(e);

return null;

}

}

private static String getRSAPublicKeyAsNetFormat(byte[] encodedPrivkey) {

try {

StringBuffer buff = new StringBuffer(1024);

PKCS8EncodedKeySpec pvkKeySpec = new PKCS8EncodedKeySpec(

encodedPrivkey);

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

RSAPublicKey pukKey = (RSAPublicKey) keyFactory

.generatePublic(new X509EncodedKeySpec(encodedPrivkey));

buff.append("");

buff.append(""

+ b64encode(removeMSZero(pukKey.getModulus()

.toByteArray())) + "");

buff.append(""

+ b64encode(removeMSZero(pukKey.getPublicExponent()

.toByteArray())) + "");

buff.append("");

return buff.toString().replaceAll("[ \t\n\r]", "");

} catch (Exception e) {

System.err.println(e);

return null;

}

}

public static String encodePublicKeyToXml(PublicKey key) {

if (!RSAPublicKey.class.isInstance(key)) {

return null;

}

RSAPublicKey pubKey = (RSAPublicKey) key;

StringBuilder sb = new StringBuilder();

sb.append("");

sb.append("").append(

Base64.encode(pubKey.getModulus().toByteArray())).append(

"");

sb.append("").append(

Base64.encode(pubKey.getPublicExponent().toByteArray()))

.append("");

sb.append("");

return sb.toString();

}

private static byte[] removeMSZero(byte[] data) {

byte[] data1;

int len = data.length;

if (data[0] == 0) {

data1 = new byte[data.length - 1];

System.arraycopy(data, 1, data1, 0, len - 1);

} else

data1 = data;

return data1;

}

private static String b64encode(byte[] data) {

String b64str = new String(Base64.encode(data));

return b64str;

}

private static byte[] b64decode(String data) {

byte[] decodeData = Base64.decode(data);

return decodeData;

}

}