pem密钥和xml密钥 pem文件获取公钥

1、入口

import java.io.File;
import java.io.FileInputStream;

import org.apache.commons.codec.binary.Base64;


public class RSACipherUtil {
	 private static String encoding ="UTF-8";
	  /**
     * RSA2解密
     * @param encrypted
     * @param encoding
     * @return
     */
    public static String RSACipherDecrypt(String encrypted){
    	String decrypted=null;
        try {
			RSACipher rsaEncrypt= new RSACipher();
			rsaEncrypt.genKeyPair();
			//加载私钥
			try {
				rsaEncrypt.loadPrivateKey(new FileInputStream(new File("D:\\Temp\\新建文件夹\\private.pem")));
				System.out.println("加载私钥成功");
			} catch (Exception e) {
				System.err.println(e.getMessage());
				System.err.println("加载私钥失败");
			}
			//解密
			byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), encrypted);
			decrypted=new String(plainText,encoding);
			System.out.println(decrypted);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return decrypted;
    }
    
    /**
     * RSA2加密字符串
     * @param clearText
     * @param encoding
     * @return
     */
    public static String RSACipherEncrypt(String clearText){
    	
    	 String encrypted=null;
    	try {
    		RSACipher rsaEncrypt= new RSACipher();
    		rsaEncrypt.genKeyPair();
    		//加载公钥
    		try {
    			rsaEncrypt.loadPublicKey(new FileInputStream(new File("D:\\Temp\\新建文件夹\\public.pem")));
    			System.out.println("加载公钥成功");
    		} catch (Exception e) {
    			System.err.println(e.getMessage());
    			System.err.println("加载公钥失败");
    		}
    		//加密
			byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), clearText);
			encrypted=Base64.encodeBase64String(cipher);
			System.out.println(encrypted);
		} catch (Exception e) {
			e.printStackTrace();
		} 
         
         
		return encrypted;
    }
    public static void main(String[] args) {
    	String encrypted = RSACipherUtil.RSACipherEncrypt("这个工具是将Apache/OpenSSL使用的“KEY文件 + CRT文件”转换为标准的PEM文件，你可以将PEM");
    	RSACipherUtil.RSACipherDecrypt(encrypted);
	}
}

 2、

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
 
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
 
import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
 
import sun.misc.BASE64Decoder;
 
public class RSACipher {
	
	
	private static int MAX_ENCRYPT_BLOCK=245;
	private static int MAX_DECRYPT_BLOCK=256;
	private static String encoding="UTF-8";
 
	/**
	 * 私钥
	 */
	private RSAPrivateKey privateKey;
 
	/**
	 * 公钥
	 */
	private RSAPublicKey publicKey;
	
	/**
	 * 字节数据转字符串专用集合
	 */
	private static final char[] HEX_CHAR= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
	
 
	/**
	 * 获取私钥
	 * @return 当前的私钥对象
	 */
	public RSAPrivateKey getPrivateKey() {
		return privateKey;
	}
 
	/**
	 * 获取公钥
	 * @return 当前的公钥对象
	 */
	public RSAPublicKey getPublicKey() {
		return publicKey;
	}
 
	/**
	 * 随机生成密钥对
	 */
	public void genKeyPair(){
		KeyPairGenerator keyPairGen= null;
		try {
			keyPairGen= KeyPairGenerator.getInstance("RSA");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		keyPairGen.initialize(2048, new SecureRandom());
		KeyPair keyPair= keyPairGen.generateKeyPair();
		this.privateKey= (RSAPrivateKey) keyPair.getPrivate();
		this.publicKey= (RSAPublicKey) keyPair.getPublic();
	}
 
	/**
	 * 从文件中输入流中加载公钥
	 * @param in 公钥输入流
	 * @throws Exception 加载公钥时产生的异常
	 */
	public void loadPublicKey(InputStream in) throws Exception{
		try {
			BufferedReader br= new BufferedReader(new InputStreamReader(in));
			String readLine= null;
			StringBuilder sb= new StringBuilder();
			while((readLine= br.readLine())!=null){
				if(readLine.charAt(0)=='-'){
					continue;
				}else{
					sb.append(readLine);
					sb.append('\r');
				}
			}
			loadPublicKey(sb.toString());
		} catch (IOException e) {
			throw new Exception("公钥数据流读取错误");
		} catch (NullPointerException e) {
			throw new Exception("公钥输入流为空");
		}
	}
 
 
	/**
	 * 从字符串中加载公钥
	 * @param publicKeyStr 公钥数据字符串
	 * @throws Exception 加载公钥时产生的异常
	 */
	public void loadPublicKey(String publicKeyStr) throws Exception{
		try {
			BASE64Decoder base64Decoder= new BASE64Decoder();
			byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);
			KeyFactory keyFactory= KeyFactory.getInstance("RSA");
			X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);
			this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);
		} catch (NoSuchAlgorithmException e) {
			throw new Exception("无此算法");
		} catch (InvalidKeySpecException e) {
			throw new Exception("公钥非法");
		} catch (IOException e) {
			throw new Exception("公钥数据内容读取错误");
		} catch (NullPointerException e) {
			throw new Exception("公钥数据为空");
		}
	}
 
	/**
	 * 从文件中加载私钥
	 * @param keyFileName 私钥文件名
	 * @return 是否成功
	 * @throws Exception 
	 */
	public void loadPrivateKey(InputStream in) throws Exception{
		try {
			BufferedReader br= new BufferedReader(new InputStreamReader(in));
			String readLine= null;
			StringBuilder sb= new StringBuilder();
			while((readLine= br.readLine())!=null){
				if(readLine.charAt(0)=='-'){
					continue;
				}else{
					sb.append(readLine);
					sb.append('\r');
				}
			}
			loadPrivateKey(sb.toString());
		} catch (IOException e) {
			throw new Exception("私钥数据读取错误");
		} catch (NullPointerException e) {
			throw new Exception("私钥输入流为空");
		}
	}
 
	public void loadPrivateKey(String privateKeyStr) throws Exception{
		try {
			BASE64Decoder base64Decoder= new BASE64Decoder();
			byte[] buffer= base64Decoder.decodeBuffer(privateKeyStr);
			PKCS8EncodedKeySpec keySpec= new PKCS8EncodedKeySpec(buffer);
			KeyFactory keyFactory= KeyFactory.getInstance("RSA");
			this.privateKey= (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
		} catch (NoSuchAlgorithmException e) {
			throw new Exception("无此算法");
		} catch (InvalidKeySpecException e) {
			throw new Exception("私钥非法");
		} catch (IOException e) {
			throw new Exception("私钥数据内容读取错误");
		} catch (NullPointerException e) {
			throw new Exception("私钥数据为空");
		}
	}
 
	/**
	 * 加密过程
	 * @param publicKey 公钥
	 * @param plainTextData 明文数据
	 * @return
	 * @throws Exception 加密过程中的异常信息
	 */
	public byte[] encrypt(RSAPublicKey publicKey,String rawText) throws Exception{
		
		if(publicKey== null){
			throw new Exception("加密公钥为空, 请设置");
		}
		Cipher cipher= null;
		try {
			cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
			cipher.init(Cipher.ENCRYPT_MODE, publicKey);
			int inputLen = rawText.getBytes(encoding).length;
	        ByteArrayOutputStream out = new ByteArrayOutputStream();
	        int offSet = 0;
	        byte[] cache;
	        int i = 0;
	        // 对数据分段加密
	        while (inputLen - offSet > 0)
	        {
	            if ( inputLen - offSet > MAX_ENCRYPT_BLOCK)
	            {
	                cache = cipher.doFinal( (rawText.getBytes(encoding)), offSet, MAX_ENCRYPT_BLOCK);
	            }
	            else
	            {
	                cache = cipher.doFinal( (rawText.getBytes(encoding)), offSet, inputLen - offSet);
	            }
	            out.write( cache, 0, cache. length);
	            i++;
	            offSet = i * MAX_ENCRYPT_BLOCK;
	        }
	        byte[] encryptedData = out.toByteArray();
	        out.close();
			// byte[] plainTextData;
			//byte[] output= cipher.doFinal(plainTextData);
			return encryptedData;
		} catch (NoSuchAlgorithmException e) {
			throw new Exception("无此加密算法");
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
			return null;
		}catch (InvalidKeyException e) {
			throw new Exception("加密公钥非法,请检查");
		} catch (IllegalBlockSizeException e) {
			throw new Exception("明文长度非法");
		} catch (BadPaddingException e) {
			throw new Exception("明文数据已损坏");
		}
	}
 
	/**
	 * 解密过程
	 * @param privateKey 私钥
	 * @param cipherData 密文数据
	 * @return 明文
	 * @throws Exception 解密过程中的异常信息
	 */
	public byte[] decrypt(RSAPrivateKey privateKey, String cipherText) throws Exception{
		if (privateKey== null){
			throw new Exception("解密私钥为空, 请设置");
		}
		Cipher cipher= null;
		try {
			cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
			cipher.init(Cipher.DECRYPT_MODE, privateKey);
			byte[] cache=Base64.decodeBase64(cipherText);
	        int inputLen = cache.length;
	        int offSet = 0;
	        StringBuffer str=new StringBuffer();
	        int i = 0;
	        // 对数据分段解密
	        while (inputLen - offSet > 0)
	        {
	            if ( inputLen - offSet > MAX_DECRYPT_BLOCK)
	            {
	            	str.append(new String(cipher.doFinal(Base64.decodeBase64(cipherText), offSet, MAX_DECRYPT_BLOCK), encoding));
	            }
	            else
	            {
	            	str.append(new String(cipher.doFinal(Base64.decodeBase64(cipherText), offSet, inputLen - offSet), encoding));
	            }
	            i++;
	            offSet = i * MAX_DECRYPT_BLOCK;
	        }
	        return str.toString().getBytes(encoding);
	        //byte[] cipherData;
			//byte[] output= cipher.doFinal(cipherData);
			//return output;
		} catch (NoSuchAlgorithmException e) {
			throw new Exception("无此解密算法");
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
			return null;
		}catch (InvalidKeyException e) {
			throw new Exception("解密私钥非法,请检查");
		} catch (IllegalBlockSizeException e) {
			throw new Exception("密文长度非法");
		} catch (BadPaddingException e) {
			throw new Exception("密文数据已损坏");
		}		
	}
 
	
	/**
	 * 字节数据转十六进制字符串
	 * @param data 输入数据
	 * @return 十六进制内容
	 */
	public static String byteArrayToString(byte[] data){
		StringBuilder stringBuilder= new StringBuilder();
		for (int i=0; i<data.length; i++){
			//取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
			stringBuilder.append(HEX_CHAR[(data[i] & 0xf0)>>> 4]);
			//取出字节的低四位 作为索引得到相应的十六进制标识符
			stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
			if (i<data.length-1){
				stringBuilder.append(' ');
			}
		}
		return stringBuilder.toString();
	}
 
 
	public static void main(String[] args){
		RSACipher rsaEncrypt= new RSACipher();
		rsaEncrypt.genKeyPair();
 
		//加载公钥
		try {
			rsaEncrypt.loadPublicKey(new FileInputStream(new File("D:\\Temp\\新建文件夹\\public.pem")));
			//rsaEncrypt.loadPublicKey(Test6.DEFAULT_PUBLIC_KEY);
			System.out.println("加载公钥成功");
		} catch (Exception e) {
			System.err.println(e.getMessage());
			System.err.println("加载公钥失败");
		}
 
		//加载私钥
		try {
			rsaEncrypt.loadPrivateKey(new FileInputStream(new File("D:\\Temp\\新建文件夹\\private.pem")));
			//rsaEncrypt.loadPrivateKey(Test6.DEFAULT_PRIVATE_KEY);
			System.out.println("加载私钥成功");
		} catch (Exception e) {
			System.err.println(e.getMessage());
			System.err.println("加载私钥失败");
		}
 
		//测试字符串
		String encryptStr= "Test String999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999\\||sdsdsds:";
		//String encryptStr= "dsfsdfsd中";
		try {
			//加密
			byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr);
			String cipherText=Base64.encodeBase64String(cipher);
			System.out.println(cipherText);
			//解密
			byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipherText);
			System.out.println("密文长度:"+ cipher.length);
			System.out.println(RSACipher.byteArrayToString(cipher));
			System.out.println("明文长度:"+ plainText.length);
			System.out.println(RSACipher.byteArrayToString(plainText));
			System.out.println(new String(plainText,encoding));
		} catch (Exception e) {
			System.err.println(e.getMessage());
		}
	}
}

生成RSA密钥

在线RSA公私密钥校验