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;

/**
 * RSA 公私钥生成及加解密
 * @author yaxiong.zhai
 *
 */
@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;
    }

    /**
     * 公钥加密过程
     * 
     * @param publicKey
     *            公钥
     * @param plainTextData
     *            明文数据
     * @return
     * @throws Exception
     *             加密过程中的异常信息
     */ 
    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("明文数据已损坏"); 
        } 
    } 
 
    /**
     * 私钥加密过程
     * 
     * @param privateKey 私钥
     * @param plainTextData 明文数据
     * @return
     * @throws 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("明文数据已损坏"); 
        } 
    } 
 
    /**
     * 私钥解密过程
     * 
     * @param privateKey 私钥
     * @param cipherData  密文数据
     * @return 明文
     * @throws 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("密文数据已损坏"); 
        } 
    } 
 
    /**
     * 公钥解密过程
     * 
     * @param publicKey  公钥
     * @param cipherData  密文数据
     * @return 明文
     * @throws 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("密文数据已损坏"); 
        } 
    } 

    /**
     * 公私钥生成，RSA加解密测试
     * @param args
     */
    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();
        }
        
    }
}