/**
 * RSA加密演算法的演示驗證
 * RSA是一種分組加密演算法
 * 注意:金鑰對採用的長度決定了加密塊的長度，我這裡取的是2048，即256byte
 * 由於加密塊的長度固定為256，因此明文的長度至多為256 - 11 = 245byte
 * 我這裡明文長度取的是128byte，密文長度為256byte，它適合於小檔案加密
 */
package encrypto;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
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.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

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

/**
 * @author liuhuabai,
 
[email protected]
 *
 */
public class RSADemo {
	/**
	 * 公鑰
	 */
	private RSAPublicKey publicKey;
	/**
	 * 私鑰
	 */
	private RSAPrivateKey privateKey;
	/**
	 * 用於加解密
	 */
	private Cipher cipher;
	/**
	 * 明文塊的長度 它必須小於密文塊的長度 - 11
	 */
	private int originLength = 128;
	/**
	 * 密文塊的長度
	 */
	private int encrytLength = 256;
	
	/**
	 * 得到初始化的公鑰和私鑰
	 * @throws NoSuchAlgorithmException 
	 * @throws NoSuchPaddingException 
	 */
	public void initKey() throws NoSuchAlgorithmException, NoSuchPaddingException {
		//RSA加密演算法：建立金鑰對，長度採用2048
		KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA");
		kg.initialize(encrytLength * 8);
		KeyPair keypair = kg.generateKeyPair();
		//分別得到公鑰和私鑰
		publicKey = (RSAPublicKey) keypair.getPublic();
		privateKey = (RSAPrivateKey) keypair.getPrivate();
	}
	/**
	 * 將公鑰儲存至檔案
	 * @param file 待寫入的檔案
	 * @return true 寫入成功;false 寫入失敗
	 */
	public boolean savePublicKey(File file) {
		return this.saveKey(publicKey, file);
	}
	/**
	 * 將私鑰保持至檔案
	 * @param file 待寫入的檔案
	 * @return true 寫入成功;false 寫入失敗
	 */
	public boolean savePrivateKey(File file) {
		return this.saveKey(privateKey, file);
	}
	//將Key檔案保持到檔案中
	private boolean saveKey(Key key,File file) {
		boolean write;
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(file);
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			//System.out.println(key.getFormat());
			//公鑰預設使用的是X.509編碼，私鑰預設採用的是PKCS #8編碼
			byte [] encode = key.getEncoded();
			//注意，此處採用writeObject方法，讀取時也要採用readObject方法
			oos.writeObject(encode);
			write = true;
		} catch (IOException e) {
			write = false;
		} finally {
				try {
					if(fos != null) fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
		}
		return write;
	}
	/**
	 * 從檔案中得到公鑰
	 * @param file 儲存公鑰的檔案
	 */
	public void getPublicKey(File file) {
		getKey(file,0);
	}
	/**
	 * 從檔案中得到私鑰
	 * @param file 儲存私鑰的檔案
	 */
	public void getPrivateKey(File file) {
		getKey(file,1);
	}
	
	private void getKey(File file,int mode) {
		FileInputStream fis;
		try {
			//讀取資料
			fis = new FileInputStream(file);
			ObjectInputStream ois = new ObjectInputStream(fis);
			byte [] keybyte = (byte[]) ois.readObject();
			//關閉資源
			ois.close();
			//預設編碼
			KeyFactory keyfactory = KeyFactory.getInstance("RSA");
			//得到公鑰或是私鑰
			if(mode == 0) {
				X509EncodedKeySpec x509eks= new X509EncodedKeySpec(keybyte);
				publicKey = (RSAPublicKey) keyfactory.generatePublic(x509eks);
				//System.out.println(pk.getAlgorithm());
			} else {
				PKCS8EncodedKeySpec pkcs8eks = new PKCS8EncodedKeySpec(keybyte);
				privateKey = (RSAPrivateKey) keyfactory.generatePrivate(pkcs8eks);
				//System.out.println(pk.getAlgorithm());
			}
		} catch (IOException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}		
	}

	/**
	 * 資料RSA加密
	 * @param origin 明文
	 * @return 密文
	 */
	protected byte [] encrypt(byte [] origin) {
		//byte [] enc = new byte [encrytLength];
		byte [] enc = null;
		try {
			cipher = Cipher.getInstance("RSA");
			cipher.init(Cipher.ENCRYPT_MODE, publicKey);
			enc = cipher.doFinal(origin);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}
		return enc;
	}
	/**
	 * 資料RSA解密
	 * @param enc 密文
	 * @return 明文
	 */
	protected byte [] decrypt(byte [] enc) {
		//byte [] origin = new byte [originLength];
		byte [] origin = null;
		try {
			cipher = Cipher.getInstance("RSA");
			cipher.init(Cipher.DECRYPT_MODE, privateKey);
			origin = cipher.doFinal(enc);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}
		return origin;
	}
	/**
	 * 加密檔案
	 * @param origin 明檔案
	 * @throws IOException
	 */
	public void encryptFile(File origin) throws IOException {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		
		//讀入
		fis = new FileInputStream(origin);
		BufferedInputStream bis = new BufferedInputStream(fis);
		byte [] originbyte = new byte [originLength];
		//寫出
		fos = new FileOutputStream(new File(origin+".encrypt"));
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		byte [] encryptbyte;
		//int k;
		while(bis.read(originbyte) > 0) {
			encryptbyte = this.encrypt(originbyte);
			bos.write(encryptbyte);
			originbyte = new byte[originLength];
		}
		//壓入
		bos.flush();
		//關閉資源
		if(fis != null) fis.close();
		if(fos != null) fos.close();		
	}
	/**
	 * 解密檔案
	 * @param encrypt 密檔案
	 * @throws IOException
	 */
	public void decryptFile(File encrypt) throws IOException {
		
		FileInputStream fis = null;
		FileOutputStream fos = null;
		//讀入
		fis = new FileInputStream(encrypt);
		BufferedInputStream bis = new BufferedInputStream(fis);
		byte [] encryptbyte = new byte [encrytLength];
		//寫出
		fos = new FileOutputStream(new File(encrypt+".decrypt"));
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		byte [] originbyte;
		
		//int k;
		while(bis.read(encryptbyte) > 0) {
			originbyte = this.decrypt(encryptbyte);
			bos.write(originbyte);
			encryptbyte = new byte [encrytLength];
		}
		//壓入
		bos.flush();
		//關閉資源
		if(fis != null) fis.close();
		if(fos != null) fos.close();
	}
	
	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws Exception {
		RSADemo rsa = new RSADemo();
		rsa.initKey();
		rsa.encryptFile(new File("E:/hello.txt"));
		rsa.decryptFile(new File("E:/hello.txt.encrypt"));
		rsa.savePublicKey(new File("E:/public.key"));
		rsa.savePrivateKey(new File("E:/private.key"));
		//rsa.getPublicKey(new File("E:/public.key"));
		//rsa.getPrivateKey(new File("E:/private.key"));
		//rsa.encryptFile(new File("E:/hello.txt"));
		//rsa.decryptFile(new File("E:/hello.txt.encrypt"));
	}
}