RAS非對稱加密解密，公鑰私鑰

package com.test;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import org.apache.commons.codec.binary.Base64;

public class RSAsecurity {
    
    public static Map<String,String> getKey(int length){
        try {
            //1.初始化秘鑰
            
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        
            //秘鑰長度
            keyPairGenerator.initialize(length);
            //初始化秘鑰對
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            //公鑰
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            //私鑰
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
            
            byte[] publicKeyByte = rsaPublicKey.getEncoded();
            
            byte[] privateKeyByte = rsaPrivateKey.getEncoded();
            
            String publicKey = Base64.encodeBase64String(publicKeyByte);
            
            String privateKey = Base64.encodeBase64String(privateKeyByte);
            
            Map<String,String> map = new HashMap<String,String>();
            
            map.put("publicKey", publicKey);
            
            map.put("privateKey", privateKey);
            
            return map;
        
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return new HashMap<String,String>();
    }
    
    public static void main(String[] args) {
        //Map<String,String> map = RSAsecurity.getKey(1024);
        //System.out.println(map.get("publicKey"));
        RSAsecurity.pubENpriDE();
        //System.out.println("---");
    }
    
    /*RSA 工具類。提供加密，解密，生成密鑰對等方法。 
    RSA加密原理概述   
    RSA的安全性依賴於大數的分解，公鑰和私鑰都是兩個大素數（大於100的十進制位）的函數。
    據猜測，從一個密鑰和密文推斷出明文的難度等同於分解兩個大素數的積   
    密鑰的產生：   
    1.選擇兩個大素數 p,q ,計算 n=p*q;   
    2.隨機選擇加密密鑰 e ,要求 e 和 (p-1)*(q-1)互質   
    3.利用 Euclid 算法計算解密密鑰 d , 使其滿足 e*d = 1(mod(p-1)*(q-1)) (其中 n,d 也要互質)   
    4:至此得出公鑰為 (n,e) 私鑰為 (n,d)   
    RSA速度   
    * 由於進行的都是大數計算，使得RSA最快的情況也比DES慢上100倍，無論 是軟件還是硬件實現。   
    * 速度一直是RSA的缺陷。一般來說只用於少量數據 加密。*/
    
    public static void priENpubDE() {
        String src="RSA 加密字符串";
        try {
            //1.初始化秘鑰
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            //秘鑰長度
            keyPairGenerator.initialize(1024);
            //初始化秘鑰對
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            //公鑰
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            String publicKeyStr = Base64.encodeBase64String(rsaPublicKey.getEncoded());
            //私鑰
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
            String privateKeyStr = Base64.encodeBase64String(rsaPrivateKey.getEncoded());
            
            //2.私鑰加密，公鑰解密----加密
            //生成私鑰
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyStr));
            KeyFactory keyFactory =KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            //Cipher類為加密和解密提供密碼功能，通過getinstance實例化對象
            Cipher cipher =Cipher.getInstance("RSA");
            //初始化加密
            cipher.init(Cipher.ENCRYPT_MODE,privateKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("私鑰加密，公鑰解密----加密:"+Base64.encodeBase64String(result));
            
            //3.私鑰加密，公鑰解密----解密
            //生成公鑰
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyStr));
            keyFactory=KeyFactory.getInstance("RSA");
            PublicKey publicKey= keyFactory.generatePublic(x509EncodedKeySpec);
            cipher = Cipher.getInstance("RSA");
            //初始化解密
            cipher.init(Cipher.DECRYPT_MODE,publicKey);
            result = cipher.doFinal(result);
            System.out.println("私鑰加密，公鑰解密----解密:"+new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void pubENpriDE() {
        String src="RSA 加密字符串";
        try {
            //1.初始化秘鑰
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            //秘鑰長度
            keyPairGenerator.initialize(512);
            //初始化秘鑰對
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            //公鑰
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            //私鑰
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
            
            //2.公鑰加密，私鑰解密----加密
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            //初始化加密
            //Cipher類為加密和解密提供密碼功能，通過getinstance實例化對象
            Cipher cipher =Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE,publicKey);
            //加密字符串
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("公鑰加密，私鑰解密----加密:"+Base64.encodeBase64String(result));

            //3.公鑰加密，私鑰解密-----解密
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());     
            keyFactory=KeyFactory.getInstance("RSA");
            PrivateKey  privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            //初始化解密
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            //解密字符串
            result = cipher.doFinal(result);
            System.out.println("公鑰加密，私鑰解密-----解密:"+new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}