rsa加密(一)

本文借鑑於http://blog.csdn.net/chaijunkun/article/details/7275632的博客

第一步：使用Openssl生成私鑰跟公鑰

 由於筆者使用阿里雲服務器ubuntu 16.04，自帶Openssl，跳過

輸入命令：openssl version -a   查詢是否安裝Openssl

生成1024位私鑰：openssl genrsa -out rsa_private_key.pem 1024

查看生成的私鑰：cat rsa_private_key.pem

根據私鑰生成公鑰：openssl rsa -in rsa_private_key.pem -out rsa_public_key.pem -pubout

查看生成的公鑰：cat rsa_public_key.pem

私鑰進行PKCS#8編碼：openssl pkcs8 -topk8 -in rsa_private_key.pem -out pkcs8_rsa_private_key.pem -nocrypt

查看編碼後的PKCS#8私鑰：cat pkcs8_rsa_private_key.pem

驗證祕鑰對是否正確的代碼如下：

package com.koow.test;


import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.io.BufferedReader;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.io.InputStream;
import java.io.InputStreamReader;
import sun.misc.BASE64Decoder;
import java.security.spec.PKCS8EncodedKeySpec;


import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;


public class RSAEncrypt {


	private static final String DEFAULT_PUBLIC_KEY = ""
			+ "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDDYMpmCWDPx6S36L"
			+ "F7N53I/7SyuCwZoSQYEbXvQzo4uX3Q1vA9ADKqNlriSpcThoWKQ4JD"
			+ "JUcFJn3rwS05TOPdNx3CIL4zT/x/XG369o9/Vzm"
			+ "7dBBcPcPvEJxm+c+oOVydwGz5NvrROXOwVmYQfm"
			+ "3Z/9LL6CfDzmR4wLFz16/OswIDAQAB";
	private static final String DEFAULT_PRIVATE_KEY = ""
			+ "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAMNgymY"
			+ "JYM/HpLfosXs3ncj/tLK4LBmhJBgRte9DOji5fdDW8D0AMqo2WuJKlx"
			+ "OGhYpDgkMlRwUmfevBLTlM4903HcIgvjNP/H9cbfr2j39XObt0EFw9w"
			+ "+8QnGb5z6g5XJ3AbPk2+tE5c7BWZhB+bdn/0svoJ8POZHjAsXPXr86z"
			+ "AgMBAAECgYA0cSuCnevNecH910ikUTZZ+EDRY9v6eSVODJrwAPSEu01"
			+ "JHBhZ107CH1rfuLO6evYnOZ2iVkQs3rsX578yzS+v/ZADdC7166KmDe"
			+ "NkEoia01cfZN1dYdvowwMVRMImokBQth8iAS8tex7EPLNtDY6LJ6rEs"
			+ "tT6an1+qfMeRn1+cQJBAPQz8d1Evo+JphCoijfFOS9d1NHihZxHD61I"
			+ "/TuJDYC/494gOflCdYQLRfwfLOeFXDpb6Ej7OiQW49+jMqZ7fHsCQQD"
			+ "M0Qea+ZfB4Y6leAUC40kF/sJLjJa2E22G+5FUVtM9HfiOlEmIW/s39V"
			+ "NwiH8/XSMPYTMz7IBb79+LJzHuke0pAkAwVB9ntPUpnwo4fcJs6yE4G"
			+ "I/HwdbDaOTXXHyRTbxYYKGOEj6m79ol+b0t+lV+tEveWNYNq3qELeuH"
			+ "FNsvS30FAkAuT/m7RkLVeU5LBieD7qbdbyy57pFJnH0Ar7O98WAUisl"
			+ "gXBGAfuQAVD3IzWSQjFvYJ29vh0PDBitzCKrWujJ5AkEA0h+tTr4CzV"
			+ "KE+nwEM+asWLAnp6bnO7NoOBv2SWkAtRXdtzz2WE+ZIGmy+AZJ/wHx4"
			+ "RCfg8P0rXov+KLVyJX+MQ==";


	/**
	 * 私鑰
	 */
	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 this.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(1024, new SecureRandom());
		KeyPair keyPair = keyPairGen.generateKeyPair();
		this.privateKey = (RSAPrivateKey) keyPair.getPrivate();
		this.publicKey = (RSAPublicKey) keyPair.getPublic();
	}


	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,byte[] plainTextDate) throws Exception{
		if(publicKey==null){
			throw new Exception("加密公鑰爲爲空，請設置");
		}
		Cipher cipher=null;
		try{
			cipher= Cipher.getInstance("RSA");
			cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
            byte[] output= cipher.doFinal(plainTextDate);  
            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 privateKey 私鑰
	 * @param cipherData 密文數據
	 * @return 明文
	 * @throws Exception 解密過程中的異常信息
	 */
	public byte[] decrypt(RSAPrivateKey privateKey,byte[] cipherData)throws Exception{
		if(privateKey==null){
			throw new Exception("解密私鑰爲空，請設置");
		}
		Cipher cipher=null;
		try{
			cipher=Cipher.getInstance("RSA");
			cipher.init(Cipher.DECRYPT_MODE, privateKey);
			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 buteArrayToString(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){
		RSAEncrypt rsaEncrypt=new RSAEncrypt();
		//rsaEncrypt.getKeyPair();
		
		//加載公鑰
		try{
			rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);
			System.out.println("加載公鑰成功");
		}catch(Exception e){
			System.err.println(e.getMessage());
			System.err.println("加載公鑰失敗");
		}
		
		//加載私鑰
		try{
			rsaEncrypt.loadPrivateKey(RSAEncrypt.DEFAULT_PRIVATE_KEY);
			System.out.println("加載私鑰成功");
		}catch(Exception e){
			System.err.println(e.getMessage());
			System.err.println("加載私鑰失敗");
		}
		
		//測試字符串
		String encryptStr="這是Koow的RSA加密解密測試!";
		
		try{
			//加密
			byte[] cipher=rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());
			//解密
			byte[] plainText=rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);
			System.out.println("密文長度:"+cipher.length);
			System.out.println(RSAEncrypt.buteArrayToString(cipher));
			System.out.println("明文長度:"+plainText.length);
			System.out.println(RSAEncrypt.buteArrayToString(plainText));
			System.out.println(new String(plainText));
		}catch (Exception e) {  
            System.err.println(e.getMessage());  
        }  
	}
	


}

結果如下：