RSA加密解密

参考了网上的一些资料：

http://blog.sina.com.cn/s/blog_76550fd7010147tp.html 

http://blog.csdn.net/centralperk/article/details/8538697

http://dustin.iteye.com/blog/763931

RSA算法密钥长度的选择是安全性和程序性能平衡的结果，密钥长度越长，安全性越好，加密解密所需时间越长。

1. 非对称加密算法中1024 bit密钥的强度相当于对称加密算法80bit密钥的强度。有资料上说以当前的软硬件水平，破解1024bit的RSA加密密文，需要一套10亿美金的系统使用若干十年的时间，所以2015年前，1024bit的还无需太担心暴力破解的危险。

2. 密钥长度增长一倍，公钥操作所需时间增加约4倍，私钥操作所需时间增加约8倍，公私钥生成时间约增长16倍。

3. 一次能加密的密文长度与密钥长度成正比， len_in_byte(raw_data) = len_in_bit(key)/8 -11，如1024bit的密钥，一次能加密的内容长度为 1024/8 -11 = 117 byte。所以非对称加密一般都用于加密对称加密算法的密钥，而不是直接加密内容。

4. 加密后密文的长度为密钥的长度，如密钥长度为1024b(128Byte)，最后生成的密文固定为 1024b(128Byte)

现整理如下：

import java.io.*;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

public class RSAUtil{

    private  static final String KEY_ALGORITHM = "RSA";//签名算法 
	
    /**
     * RSA解密要求密文最大长度为128字节，加密明文最大长度117字节  
     * 如果加密数据过大需要在加密和解密的过程中需要分块进行
     * 块数=(明文长度(bytes)/(密钥长度(需要将bit转换为bytes)-11))向上取整,就是不满一片的按一片算
     * 所以密文的长度设置直接影响块数的大小，可以根据项目需要灵活分配分块的个数
     * RSA最大密文长度 单位：byte
     */
    private  static final int DECRYPT_LENGTH = 128;
    /**
     * RSA最大明文长度 单位：byte
     */
    private  static final int ENCRYPT_LENGTH = DECRYPT_LENGTH - 11;
    /**
	 *密钥长度 单位：bit  1byte=8bit 
	 *加密n byte的明文,需要至少(n+11)bytes的密钥
	 *因为该单位是bit 所以换算成bit就要乘以8
	 */
    private  static final int ENCRYTLENGTH = (ENCRYPT_LENGTH + 11) * 8;
    /**
     * 注意下面两个路径必须存在，否则在初始化过程中会发生异常
     */
    private  static final String PUBLICKEYPATH = "/home/key/public.key";
    private  static final String PRIVATEKEYPATH = "/home/key/private.key";
    private  static RSAPublicKey publicKey;
    private  static RSAPrivateKey privateKey;
    public enum KeyType{ PUBLIC,PRIVATE; }

    static{
        try {
            initKey(true);
        } catch (Exception e) {
        	e.printStackTrace();
            throw new RuntimeException("初始化key异常！！");
        }
    }
    
    public static void main(String[] args) throws Exception {
        String data = "hello world";
        File publickeyFile = new File(PUBLICKEYPATH);
        File privatekeyFile = new File(PRIVATEKEYPATH);
        byte[] encryptData,decryptData;
        if(publickeyFile.exists() && privatekeyFile.exists()){
        	Key publickey = getKey(publickeyFile, KeyType.PUBLIC);
        	Key privatekey = getKey(privatekeyFile, KeyType.PRIVATE);
        	encryptData = encrypt(data.getBytes(), publickey);
        	decryptData = decrypt(encryptData, privatekey);
        	System.out.println("用文件路径方式的key进行加密！！！");
        }else{
        	encryptData = encrypt(data.getBytes());
        	decryptData = decrypt(encryptData);
        	System.out.println("用系统初始化的key进行加密！！！");
        }
        System.out.println("加密后：" + new String(encryptData, "UTF-8"));
    	System.out.println(new String(decryptData));
        
    }
    /**
     * @param isSaveKey //初始化是否将key保存为文件 true是 false不是
     * @throws Exception
     */
    private static void initKey(boolean isSaveKey) throws Exception {
        KeyPairGenerator kg = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        kg.initialize(ENCRYTLENGTH);
        KeyPair keypair = kg.generateKeyPair();
        //得到公钥和私钥
        publicKey = (RSAPublicKey) keypair.getPublic();
        privateKey = (RSAPrivateKey) keypair.getPrivate();
        if(isSaveKey){
        	File publicKeyFile = new File(PUBLICKEYPATH);
        	File privateKeyFile = new File(PRIVATEKEYPATH);
        	if(publicKeyFile.exists() && privateKeyFile.exists()){
        		generateKeyToFile(publicKey,  publicKeyFile);
        		generateKeyToFile(privateKey, privateKeyFile);
        	}else{
        		throw new RuntimeException("生成key文件的路径错误！！！");
        	}
        }
    }
    /**
     * 将key生成到文件
     * @param key
     * @param file
     * @return
     * @throws IOException
     */
    private static boolean generateKeyToFile(Key key,File file) throws IOException {
        boolean flag = false;
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        try {
            fos = new FileOutputStream(file);
            oos = new ObjectOutputStream(fos);
            //公钥默认使用的是X.509编码，私钥默认采用的是PKCS8编码
            byte [] encode = key.getEncoded();
            //注意，此处采用writeObject方法，读取时也要采用readObject方法
            oos.writeObject(encode);
            flag = true;
        } catch (IOException e) {
            throw e;
        } finally {
            if(fos != null) fos.close();
            if(oos != null) oos.close();
        }
        return flag;
    }
    /**
     * @param keybyte
     * @param type
     * @return
     * @throws Exception
     */
    private static Key getKey( byte[] keybyte, KeyType type) throws Exception {
    	KeyFactory keyfactory = KeyFactory.getInstance(KEY_ALGORITHM);
        if (type == KeyType.PUBLIC) {
            X509EncodedKeySpec x509eks = new X509EncodedKeySpec(keybyte);
            RSAPublicKey publicKey = (RSAPublicKey) keyfactory.generatePublic(x509eks);
            return publicKey;
        } else if (type == KeyType.PRIVATE) {
            PKCS8EncodedKeySpec pkcs8eks = new PKCS8EncodedKeySpec(keybyte);
            RSAPrivateKey privateKey = (RSAPrivateKey) keyfactory.generatePrivate(pkcs8eks);
            return privateKey;
        }
        return null;
    }
    /**
     * @param keyFile
     * @param type
     * @return
     * @throws Exception
     */
    private static Key getKey(File keyFile, KeyType type) throws Exception {
        FileInputStream fis = new FileInputStream(keyFile);
        ObjectInputStream ois = new ObjectInputStream(fis);
        byte[] keybyte = (byte[]) ois.readObject();
        ois.close();
        return getKey(keybyte,type);
    }

    /**
     * @param type
     * @return
     * @throws Exception
     */
    private static Key getKey(KeyType type) throws Exception {
        if (type == KeyType.PUBLIC) {
           return publicKey;
        } else if (type == KeyType.PRIVATE) {
            return privateKey;
        }
        return null;
    }

    /**
     * @param data
     * @param publicKey
     * @return
     * @throws Exception
     */
    private static byte[] encrypt(byte[] data, Key publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > ENCRYPT_LENGTH) {
                cache = cipher.doFinal(data, offSet, ENCRYPT_LENGTH);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * ENCRYPT_LENGTH;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }
    
    /**
     * @param data
     * @param keyFile
     * @return
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data,File keyFile) throws Exception {
    	 Key publicKey = getKey(keyFile, KeyType.PUBLIC);
    	 return encrypt(data,publicKey);
    }
    /**
     * @param data
     * @param keyByte
     * @return
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data,byte[] keyByte) throws Exception {
    	Key publicKey = getKey(keyByte,KeyType.PUBLIC);
        return encrypt(data,publicKey);
    }
    /**
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data) throws Exception {
    	return encrypt(data,publicKey);
    }
    /**
     *
     * @param data
     * @param privateKey
     * @return
     * @throws Exception
     */
    private static byte[] decrypt(byte[] data, Key privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
       // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > DECRYPT_LENGTH) {
                cache = cipher.doFinal(data, offSet, DECRYPT_LENGTH);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * DECRYPT_LENGTH;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }
    /**
     * @param data
     * @param privateKeyBytes
     * @return
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, byte[] privateKeyBytes) throws Exception {
        Key privateKey = getKey(privateKeyBytes,KeyType.PRIVATE);
        return decrypt(data,privateKey);
    }
    /**
     * @param data
     * @param keyFile
     * @return
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data,File keyFile) throws Exception {
   	 Key privateKey = getKey(keyFile, KeyType.PRIVATE);
   	 return decrypt(data,privateKey);
   }

    /**
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data) throws Exception {
        return decrypt(data,privateKey);
    }
}