RSA公私鑰生成及RSA公私鑰加解密

package test;

import java.security.InvalidKeyException;

import java.security.Key;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.InvalidKeySpecException;

import java.util.HashMap;

import java.util.Map;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

import org.webbitserver.helpers.Base64;

import sun.misc.BASE64Decoder;

import sun.misc.BASE64Encoder;

@SuppressWarnings("restriction")

public class CreateSecrteKey {

    public class Keys {

    }

    public static final String KEY_ALGORITHM = "RSA";

    private static final String PUBLIC_KEY = "RSAPublicKey";

    private static final String PRIVATE_KEY = "RSAPrivateKey";

    //獲得公鑰

    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {

        //獲得map中的公鑰對象 轉為key對象

        Key key = (Key) keyMap.get(PUBLIC_KEY);

        //byte[] publicKey = key.getEncoded();

        //編碼傳回字元串

        return encryptBASE64(key.getEncoded());

    }

    //獲得私鑰

    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {

        //獲得map中的私鑰對象 轉為key對象

        Key key = (Key) keyMap.get(PRIVATE_KEY);

        //byte[] privateKey = key.getEncoded();

        //編碼傳回字元串

        return encryptBASE64(key.getEncoded());

    }

    //解碼傳回byte

    public static byte[] decryptBASE64(String key) throws Exception {

        return (new BASE64Decoder()).decodeBuffer(key);

    }

    //編碼傳回字元串

    public static String encryptBASE64(byte[] key) throws Exception {

        return (new BASE64Encoder()).encodeBuffer(key);

    }

    //map對象中存放公私鑰

    public static Map<String, Object> initKey() throws Exception {

        //獲得對象 KeyPairGenerator 參數 RSA 1024個位元組

        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);

        keyPairGen.initialize(1024);

        //通過對象 KeyPairGenerator 擷取對象KeyPair

        KeyPair keyPair = keyPairGen.generateKeyPair();

        //通過對象 KeyPair 擷取RSA公私鑰對象RSAPublicKey RSAPrivateKey

        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        //公私鑰對象存入map中

        Map<String, Object> keyMap = new HashMap<String, Object>(2);

        keyMap.put(PUBLIC_KEY, publicKey);

        keyMap.put(PRIVATE_KEY, privateKey);

        return keyMap;

    }

    public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) 

            throws Exception { 

        if (publicKey == null) { 

            throw new Exception("加密公鑰為空, 請設定"); 

        } 

        try { 

            // 使用預設RSA 

            Cipher cipher = Cipher.getInstance("RSA"); 

            // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider()); 

            cipher.init(Cipher.ENCRYPT_MODE, publicKey); 

            byte[] output = cipher.doFinal(plainTextData); 

            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("明文資料已損壞"); 

        } 

    } 

    public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData) 

            throws Exception { 

        if (privateKey == null) { 

            throw new Exception("加密私鑰為空, 請設定"); 

        } 

        try { 

            // 使用預設RSA 

            Cipher cipher = Cipher.getInstance("RSA"); 

            cipher.init(Cipher.ENCRYPT_MODE, privateKey); 

            byte[] output = cipher.doFinal(plainTextData); 

            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("明文資料已損壞"); 

        } 

    } 

    public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) 

            throws Exception { 

        if (privateKey == null) { 

            throw new Exception("解密私鑰為空, 請設定"); 

        } 

        try { 

            // 使用預設RSA 

            Cipher cipher = Cipher.getInstance("RSA"); 

            // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider()); 

            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("密文資料已損壞"); 

        } 

    } 

    public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData) 

            throws Exception { 

        if (publicKey == null) { 

            throw new Exception("解密公鑰為空, 請設定"); 

        } 

        try { 

            // 使用預設RSA 

            Cipher cipher = Cipher.getInstance("RSA"); 

            cipher.init(Cipher.DECRYPT_MODE, publicKey); 

            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("密文資料已損壞"); 

        } 

    } 

    public static void main(String[] args) {

        Map<String, Object> keyMap;

        try {

            keyMap = initKey();

            String publicKey = getPublicKey(keyMap);

            System.out.println(publicKey);

            String privateKey = getPrivateKey(keyMap);

            System.out.println(privateKey);

            String str = "abc";

            String encode = Base64.encode(encrypt((RSAPublicKey) keyMap.get(PUBLIC_KEY), str.getBytes()));

            System.out.println(encode);

            String decode = new String(decrypt(((RSAPrivateKey) keyMap.get(PRIVATE_KEY)),Base64.decode(encode)));

            System.out.println(decode);

            String encode1 = Base64.encode(encrypt((RSAPrivateKey) keyMap.get(PRIVATE_KEY),str.getBytes()));

            System.out.println(encode1);

            String decode1 = new String(decrypt((RSAPublicKey) keyMap.get(PUBLIC_KEY), Base64.decode(encode1)));

            System.out.println(decode1);

        } catch (NoSuchAlgorithmException e) {

            e.printStackTrace();

        } catch (InvalidKeySpecException e) {

            e.printStackTrace();

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}