把Java生成的RSA公钥、私钥转换成.NET使用的XML格式详解编程语言

PrivateKey privateKey=RSAUtils.getRSAPrivateKeyBybase64(savePrivateKey); 
PublicKey publicKey=RSAUtils.getRSAPublidKeyBybase64(savePublicKey); 
String publicKeyXml = getRSAPublicKeyAsNetFormat(publicKey.getEncoded()); 
String privateKeyXml = getRSAPrivateKeyAsNetFormat(privateKey.getEncoded());

import java.security.KeyFactory; 
import java.security.interfaces.RSAPrivateCrtKey; 
import java.security.interfaces.RSAPublicKey; 
import java.security.spec.PKCS8EncodedKeySpec; 
import java.security.spec.X509EncodedKeySpec;

 1  private static String getRSAPrivateKeyAsNetFormat(byte[] encodedPrivkey) { 
 2         try { 
 3             StringBuffer buff = new StringBuffer(1024); 
 4  
 5             PKCS8EncodedKeySpec pvkKeySpec = new PKCS8EncodedKeySpec( 
 6                     encodedPrivkey); 
 7             KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
 8             RSAPrivateCrtKey pvkKey = (RSAPrivateCrtKey) keyFactory 
 9                     .generatePrivate(pvkKeySpec); 
10  
11             buff.append("<RSAKeyValue>"); 
12             buff.append("<Modulus>" 
13                     + CodeUtils.base64Encode(removeMSZero(pvkKey.getModulus().toByteArray())) 
14                     + "</Modulus>"); 
15  
16             buff.append("<Exponent>" 
17                     + CodeUtils.base64Encode(removeMSZero(pvkKey.getPublicExponent() 
18                     .toByteArray())) + "</Exponent>"); 
19  
20             buff.append("<P>" 
21                     + CodeUtils.base64Encode(removeMSZero(pvkKey.getPrimeP().toByteArray())) 
22                     + "</P>"); 
23  
24             buff.append("<Q>" 
25                     + CodeUtils.base64Encode(removeMSZero(pvkKey.getPrimeQ().toByteArray())) 
26                     + "</Q>"); 
27  
28             buff.append("<DP>" 
29                     + CodeUtils.base64Encode(removeMSZero(pvkKey.getPrimeExponentP() 
30                     .toByteArray())) + "</DP>"); 
31  
32             buff.append("<DQ>" 
33                     + CodeUtils.base64Encode(removeMSZero(pvkKey.getPrimeExponentQ() 
34                     .toByteArray())) + "</DQ>"); 
35  
36             buff.append("<InverseQ>" 
37                     + CodeUtils.base64Encode(removeMSZero(pvkKey.getCrtCoefficient() 
38                     .toByteArray())) + "</InverseQ>"); 
39  
40             buff.append("<D>" 
41                     + CodeUtils.base64Encode(removeMSZero(pvkKey.getPrivateExponent() 
42                     .toByteArray())) + "</D>"); 
43             buff.append("</RSAKeyValue>"); 
44  
45             return buff.toString().replaceAll("[ /t/n/r]", ""); 
46         } catch (Exception e) { 
47             System.err.println(e); 
48             return null; 
49         } 
50     } 
51  
52     private static String getRSAPublicKeyAsNetFormat(byte[] encodedPublicKey) { 
53         try { 
54  
55             KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
56             RSAPublicKey pukKey = (RSAPublicKey) keyFactory.generatePublic(new X509EncodedKeySpec(encodedPublicKey)); 
57  
58             StringBuffer buff = new StringBuffer(1024); 
59             buff.append("<RSAKeyValue>"); 
60             buff.append("<Modulus>" 
61                     + CodeUtils.base64Encode(removeMSZero(pukKey.getModulus().toByteArray())) 
62                     + "</Modulus>"); 
63             buff.append("<Exponent>" 
64                     + CodeUtils.base64Encode(removeMSZero(pukKey.getPublicExponent().toByteArray())) + "</Exponent>"); 
65             buff.append("</RSAKeyValue>"); 
11 
66             return buff.toString().replaceAll("[ /t/n/r]", ""); 
67         } catch (Exception e) { 
68             System.err.println(e); 
69             return null; 
70         } 
71     }

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

// 
// Source code recreated from a .class file by IntelliJ IDEA 
// (powered by Fernflower decompiler) 
// 
 
package com.union.pufa; 
import java.math.BigInteger; 
import java.security.Key; 
import java.security.KeyFactory; 
import java.security.KeyPair; 
import java.security.KeyPairGenerator; 
import java.security.NoSuchAlgorithmException; 
import java.security.PrivateKey; 
import java.security.Provider; 
import java.security.PublicKey; 
import java.security.SecureRandom; 
import java.security.Signature; 
import java.security.interfaces.RSAPrivateKey; 
import java.security.interfaces.RSAPublicKey; 
import java.security.spec.InvalidKeySpecException; 
import java.security.spec.PKCS8EncodedKeySpec; 
import java.security.spec.RSAKeyGenParameterSpec; 
import java.security.spec.RSAPrivateKeySpec; 
import java.security.spec.RSAPublicKeySpec; 
import java.security.spec.X509EncodedKeySpec; 
import javax.crypto.Cipher; 
import org.apache.commons.codec.binary.Hex; 
import org.apache.commons.lang.StringUtils; 
import org.bouncycastle.jce.provider.BouncyCastleProvider; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
public abstract class RSAUtils { 
private static final Logger LOGGER = LoggerFactory.getLogger(RSAUtils.class); 
private static final String ALGORITHOM = "RSA"; 
private static final Provider DEFAULT_PROVIDER = new BouncyCastleProvider(); 
private static final String SIGNATURE_MD5WITHRSA = "MD5withRSA"; 
private static final String SIGNATURE_SHA1WITHRSA = "SHA1withRSA"; 
private static final String SIGNATURE_ALGORITHM_DEFAULT = "NONEwithRSA"; 
private static final String CIPHER_TRANSFORMATION_DEFAULT = "RSA/ECB/PKCS1Padding"; 
private static final String HASHID_SHA1 = "01"; 
private static final String HASHID_MD5 = "02"; 
private static KeyPairGenerator keyPairGen = null; 
private static KeyFactory keyFactory = null; 
static { 
try { 
keyPairGen = KeyPairGenerator.getInstance("RSA", DEFAULT_PROVIDER); 
keyFactory = KeyFactory.getInstance("RSA", DEFAULT_PROVIDER); 
} catch (NoSuchAlgorithmException var1) { 
LOGGER.error(var1.getMessage()); 
} 
} 
private RSAUtils() { 
} 
public static synchronized KeyPair generateRSAKeyPair(int keysize, BigInteger publicExponent) { 
try { 
keyPairGen.initialize(new RSAKeyGenParameterSpec(keysize, publicExponent), new SecureRandom()); 
return keyPairGen.generateKeyPair(); 
} catch (Exception var3) { 
LOGGER.error("生成模长 =" + keysize + "，指数=" + publicExponent + "的RSA密钥对失败", var3); 
return null; 
} 
} 
public static PrivateKey getRSAPrivateKey(String hexModulus, String hexPrivateExponent) { 
if(!StringUtils.isBlank(hexModulus) && !StringUtils.isBlank(hexPrivateExponent)) { 
BigInteger mbig = new BigInteger(hexModulus, 16); 
BigInteger ebig = new BigInteger(hexPrivateExponent, 16); 
RSAPrivateKeySpec prispec = new RSAPrivateKeySpec(mbig, ebig); 
try { 
return keyFactory.generatePrivate(prispec); 
} catch (InvalidKeySpecException var6) { 
LOGGER.error("hexModulus or hexPrivateExponent value is invalid. return null(RSAPrivateKey)."); 
return null; 
} 
} else { 
if(LOGGER.isDebugEnabled()) { 
LOGGER.debug("hexModulus and hexPrivateExponent cannot be empty. RSAPrivateKey value is null to return."); 
} 
return null; 
} 
} 
public static PublicKey getRSAPublidKey(String hexModulus, String hexPublicExponent) { 
if(!StringUtils.isBlank(hexModulus) && !StringUtils.isBlank(hexPublicExponent)) { 
BigInteger mbig = new BigInteger(hexModulus, 16); 
BigInteger ebig = new BigInteger(hexPublicExponent, 16); 
RSAPublicKeySpec pubspec = new RSAPublicKeySpec(mbig, ebig); 
try { 
return keyFactory.generatePublic(pubspec); 
} catch (InvalidKeySpecException var6) { 
LOGGER.error("hexModulus or hexPublicExponent value is invalid. return null(RSAPublicKey)."); 
return null; 
} 
} else { 
if(LOGGER.isDebugEnabled()) { 
LOGGER.debug("hexModulus and hexPublicExponent cannot be empty. return null(RSAPublicKey)."); 
} 
return null; 
} 
} 
public static String getBase64CodeKey(Key key) { 
return CodeUtils.base64Encode(key.getEncoded()); 
} 
public static String getNakedPublicKey(RSAPublicKey key) { 
return key.getModulus().toString(16).toUpperCase(); 
} 
private static byte[] getAsn1Len(int len) { 
int ret = false; 
byte[] buff = new byte[10]; 
byte[] asn1Len = (byte[])null; 
if(len > '/uffff') { 
return null; 
} else { 
byte ret; 
if(len > 255) { 
buff[0] = -126; 
buff[1] = (byte)((len & '/uff00') >> 8); 
buff[2] = (byte)(len & 255); 
ret = 3; 
} else if((len & 128) != 0) { 
buff[0] = -127; 
buff[1] = (byte)len; 
ret = 2; 
} else { 
buff[0] = (byte)len; 
ret = 1; 
} 
asn1Len = new byte[ret]; 
System.arraycopy(buff, 0, asn1Len, 0, ret); 
return asn1Len; 
} 
} 
public static byte[] getDerPK(byte[] pkModule, byte[] exp) { 
byte[] buff = new byte[4096]; 
byte[] tbuff = new byte[4096]; 
byte[] tmp = (byte[])null; 
byte[] derPK = (byte[])null; 
int offset = false; 
int len = false; 
int lenOfPkModule = pkModule.length; 
int lenOfExp = exp.length; 
if(pkModule != null && exp != null) { 
int offset = 0; 
tbuff[offset] = 2; 
int offset = offset + 1; 
tmp = getAsn1Len(lenOfPkModule + 1); 
System.arraycopy(tmp, 0, tbuff, offset, tmp.length); 
offset += tmp.length; 
tbuff[offset] = 0; 
++offset; 
System.arraycopy(pkModule, 0, tbuff, offset, lenOfPkModule); 
offset += lenOfPkModule; 
tbuff[offset] = 2; 
++offset; 
tmp = getAsn1Len(lenOfExp); 
System.arraycopy(tmp, 0, tbuff, offset, tmp.length); 
offset += tmp.length; 
System.arraycopy(exp, 0, tbuff, offset, lenOfExp); 
offset += lenOfExp; 
int len = offset; 
offset = 0; 
buff[offset] = 48; 
offset = offset + 1; 
tmp = getAsn1Len(len); 
System.arraycopy(tmp, 0, buff, offset, tmp.length); 
offset += tmp.length; 
System.arraycopy(tbuff, 0, buff, offset, len); 
offset += len; 
derPK = new byte[offset]; 
System.arraycopy(buff, 0, derPK, 0, offset); 
return derPK; 
} else { 
return null; 
} 
} 
public static String getDerPKWithAscHex(String pkModule, String exp) { 
return pkModule != null && exp != null?CodeUtils.byte2hex(getDerPK(CodeUtils.hex2byte(pkModule), CodeUtils.hex2byte(exp))):null; 
} 
public static PublicKey getPKfromDerPK(String racalPK) { 
byte[] racalPKStr = (byte[])null; 
if(racalPK == null) { 
return null; 
} else { 
racalPKStr = CodeUtils.hex2byte(racalPK); 
int offset = 0; 
if(racalPKStr[offset] != 48) { 
return null; 
} else { 
int offset = offset + 1; 
int i; 
int lenOfNextPart; 
int bitsOfLenFlag; 
if((racalPKStr[offset] & 255) <= 128) { 
lenOfNextPart = racalPKStr[offset] & 255; 
++offset; 
} else { 
bitsOfLenFlag = (racalPKStr[offset] & 255) - 128; 
++offset; 
i = 0; 
for(lenOfNextPart = 0; i < bitsOfLenFlag; ++offset) { 
lenOfNextPart += racalPKStr[offset] & 255; 
++i; 
} 
} 
if((racalPKStr[offset] & 255) != 2) { 
return null; 
} else { 
++offset; 
--lenOfNextPart; 
int lenOfPK = false; 
int lenOfPK; 
if((racalPKStr[offset] & 255) <= 128) { 
lenOfPK = racalPKStr[offset] & 255; 
++offset; 
} else { 
bitsOfLenFlag = (racalPKStr[offset] & 255) - 128; 
++offset; 
i = 0; 
for(lenOfPK = 0; i < bitsOfLenFlag; ++offset) { 
lenOfPK += racalPKStr[offset] & 255; 
++i; 
} 
} 
while(lenOfPK % 8 != 0) { 
if((racalPKStr[offset] & 255) != 0) { 
return null; 
} 
++offset; 
--lenOfPK; 
} 
byte[] LPk = new byte[lenOfPK]; 
System.arraycopy(racalPKStr, offset, LPk, 0, lenOfPK); 
String pk = CodeUtils.byte2hex(LPk); 
offset += lenOfPK; 
int lenOfEval = false; 
if(racalPKStr[offset] != 2) { 
return null; 
} else { 
++offset; 
int lenOfEval = racalPKStr[offset]; 
++offset; 
byte[] LPkEval = new byte[lenOfEval]; 
System.arraycopy(racalPKStr, offset, LPkEval, 0, lenOfEval); 
return getRSAPublidKey(pk, CodeUtils.byte2hex(LPkEval)); 
} 
} 
} 
} 
} 
public static RSAPublicKey getRSAPublidKeyBybase64(String base64s) { 
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(CodeUtils.base64Decode(base64s)); 
RSAPublicKey publicKey = null; 
try { 
publicKey = (RSAPublicKey)keyFactory.generatePublic(keySpec); 
} catch (InvalidKeySpecException var4) { 
LOGGER.error("base64编码=" + base64s + "转RSA公钥失败", var4); 
} 
return publicKey; 
} 
public static RSAPrivateKey getRSAPrivateKeyBybase64(String base64s) { 
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(CodeUtils.base64Decode(base64s)); 
RSAPrivateKey privateKey = null; 
try { 
privateKey = (RSAPrivateKey)keyFactory.generatePrivate(keySpec); 
} catch (InvalidKeySpecException var4) { 
LOGGER.error("base64编码=" + base64s + "转RSA私钥失败", var4); 
} 
return privateKey; 
} 
public static byte[] encrypt(Key key, byte[] data) throws Exception { 
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", DEFAULT_PROVIDER); 
cipher.init(1, key); 
return cipher.doFinal(data); 
} 
public static byte[] decrypt(Key key, byte[] data) throws Exception { 
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", DEFAULT_PROVIDER); 
cipher.init(2, key); 
return cipher.doFinal(data); 
} 
public static String encryptString(Key key, String plaintext) { 
if(key != null && plaintext != null) { 
byte[] data = plaintext.getBytes(); 
try { 
byte[] en_data = encrypt(key, data); 
return new String(Hex.encodeHex(en_data)); 
} catch (Exception var4) { 
LOGGER.error(var4.getCause().getMessage()); 
return null; 
} 
} else { 
return null; 
} 
} 
public static String encryptStr4essc(Key key, String plaintext, String accNo, String encType) { 
if(key != null && plaintext != null) { 
if("1".equals(encType)) { 
plaintext = CodeUtils.paddingRightStr(plaintext, 'F', 16); 
} else if("0".equals(encType)) { 
plaintext = CodeUtils.asc2ascInt2hexasc(CodeUtils.paddingRightStr(plaintext, 'F', 16)); 
} 
byte[] data = CodeUtils.hex2byte(plaintext); 
try { 
byte[] en_data = encrypt(key, data); 
return (new String(Hex.encodeHex(en_data))).toUpperCase(); 
} catch (Exception var6) { 
LOGGER.error(var6.getCause().getMessage()); 
return null; 
} 
} else { 
return null; 
} 
} 
public static String decryptString(Key key, String encrypttext) { 
if(key != null && !StringUtils.isBlank(encrypttext)) { 
try { 
byte[] en_data = Hex.decodeHex(encrypttext.toCharArray()); 
byte[] data = decrypt(key, en_data); 
return new String(data); 
} catch (Exception var4) { 
LOGGER.error(String.format("/"%s/" Decryption failed. Cause: %s", new Object[]{encrypttext, var4.getCause().getMessage()})); 
return null; 
} 
} else { 
return null; 
} 
} 
public static String sign(RSAPrivateKey privatekey, String dataFillMode, String hashID, String data) throws Exception { 
Signature signature = Signature.getInstance("NONEwithRSA"); 
if("01".equals(hashID)) { 
data = CodeUtils.sha1String(data).toUpperCase(); 
} else if("02".equals(hashID)) { 
data = CodeUtils.md5String(data).toUpperCase(); 
} 
signature.initSign(privatekey); 
signature.update(data.getBytes()); 
return CodeUtils.byte2hex(signature.sign()).toUpperCase(); 
} 
public static boolean verifySign(PublicKey publicKey, String dataFillMode, String hashID, String data, String sign) throws Exception { 
Signature signature = Signature.getInstance("NONEwithRSA"); 
if("01".equals(hashID)) { 
data = CodeUtils.sha1String(data).toUpperCase(); 
} else if("02".equals(hashID)) { 
data = CodeUtils.md5String(data).toUpperCase(); 
} 
signature.initVerify(publicKey); 
signature.update(data.getBytes()); 
return signature.verify(CodeUtils.hex2byte(sign.toUpperCase())); 
} 
}