java中rsa使用簡述（rsa是基於）

本文目錄一覽：

• 1、怎樣用Java實現RSA加密
• 2、java RSA實現對文件加密解密
• 3、JAVA裡面RSA加密演算法的使用
• 4、RSA PKCS#1在java中怎麼實現？
• 5、請高手指教如何用java編寫RSA演算法？謝謝
• 6、如何用java實現128位密鑰的RSA演算法

怎樣用Java實現RSA加密

提供加密，解密，生成密鑰對等方法。�梢願�模��遣灰��螅�裨蛐�駛岬� keyPairGen.initialize(KEY_SIZE, new SecureRandom()); KeyPair keyPair = keyPairGen.genKeyPair(); return keyPair; } catch (Exception e) { throw new Exception(e.getMessage()); } } /** * 生成公鑰 * @param modulus * @param publicExponent * @return RSAPublicKey * @throws Exception */ public static RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) throws Exception { KeyFactory keyFac = null; try { keyFac = KeyFactory.getInstance(“RSA”, new org.bouncycastle.jce.provider.BouncyCastleProvider()); } catch (NoSuchAlgorithmException ex) { throw new Exception(ex.getMessage()); } RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(modulus), new BigInteger(publicExponent)); try { return (RSAPublicKey) keyFac.generatePublic(pubKeySpec); } catch (InvalidKeySpecException ex) { throw new Exception(ex.getMessage()); } } /** * 生成私鑰 * @param modulus * @param privateExponent * @return RSAPrivateKey * @throws Exception */ public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) throws Exception { KeyFactory keyFac = null; try { keyFac = KeyFactory.getInstance(“RSA”, new org.bouncycastle.jce.provider.BouncyCastleProvider()); } catch (NoSuchAlgorithmException ex) { throw new Exception(ex.getMessage()); } RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(privateExponent)); try { return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec); } catch (InvalidKeySpecException ex) { throw new Exception(ex.getMessage()); } } /** * 加密 * @param key 加密的密鑰 * @param data 待加密的明文數據 * @return 加密後的數據 * @throws Exception */ public static byte[] encrypt(Key key, byte[] data) throws Exception { try { Cipher cipher = Cipher.getInstance(“RSA”, new org.bouncycastle.jce.provider.BouncyCastleProvider()); cipher.init(Cipher.ENCRYPT_MODE, key); int blockSize = cipher.getBlockSize();//獲得加密塊大小� i++; } return raw; } catch (Exception e) { throw new Exception(e.getMessage()); } } /** * 解密 * @param key 解密的密鑰 * @param raw 已經加密的數據 * @return 解密後的明文 * @throws Exception */ public static byte[] decrypt(Key key, byte[] raw) throws Exception { try { Cipher cipher = Cipher.getInstance(“RSA”, new org.bouncycastle.jce.provider.BouncyCastleProvider()); cipher.init(cipher.DECRYPT_MODE, key); int blockSize = cipher.getBlockSize(); ByteArrayOutputStream bout = new ByteArrayOutputStream(64); int j = 0; while (raw.length – j * blockSize 0) { bout.write(cipher.doFinal(raw, j * blockSize, blockSize)); j++; } return bout.toByteArray(); } catch (Exception e) { throw new Exception(e.getMessage()); } } /** * * @param args * @throws Exception */ public static void main(String[] args) throws Exception { File file = new File(“c:/test.html”); FileInputStream in = new FileInputStream(file); ByteArrayOutputStream bout = new ByteArrayOutputStream(); byte[] tmpbuf = new byte[1024]; int count = 0; while ((count = in.read(tmpbuf)) != -1) { bout.write(tmpbuf, 0, count); tmpbuf = new byte[1024]; } in.close(); byte[] orgData = bout.toByteArray(); KeyPair keyPair = RSA.generateKeyPair(); RSAPublicKey pubKey = (RSAPublicKey) keyPair.getPublic(); RSAPrivateKey priKey = (RSAPrivateKey) keyPair.getPrivate(); byte[] pubModBytes = pubKey.getModulus().toByteArray(); byte[] pubPubExpBytes = pubKey.getPublicExponent().toByteArray(); byte[] priModBytes = priKey.getModulus().toByteArray(); byte[] priPriExpBytes = priKey.getPrivateExponent().toByteArray(); RSAPublicKey recoveryPubKey = RSA.generateRSAPublicKey(pubModBytes,pubPubExpBytes); RSAPrivateKey recoveryPriKey = RSA.generateRSAPrivateKey(priModBytes,priPriExpBytes); byte[] raw = RSA.encrypt(priKey, orgData); file = new File(“c:/encrypt_result.dat”); OutputStream out = new FileOutputStream(file); out.write(raw); out.close(); byte[] data = RSA.decrypt(recoveryPubKey, raw); file = new File(“c:/decrypt_result.html”); out = new FileOutputStream(file); out.write(data); out.flush(); out.close(); } } （責任編輯：雲子）

java RSA實現對文件加密解密

這個我不清楚。

對文件加密，我使用的是超級加密3000.

超級加密3000採用國際上成熟的加密演算法和安全快速的加密方法，可以有效保障數據安全!

具體操作方法：

1下載安裝超級加密3000。

2 然後在需要加密的文件上單擊滑鼠右鍵選擇加密。

3 在彈出的文件加密窗口中設置文件加密密碼就OK了。

超級加密3000的下載地址你可以在百度上搜索超級加密3000，第一個就是。

JAVA裡面RSA加密演算法的使用

RSA的Java實現不能一次加密很大的字元，自己處理了一下，見下面的代碼。Base64編碼類用的是一個Public domain Base64 for java 其他的保存公鑰到文件等簡單的實現，就不詳細說了，看代碼吧。==============================================import java.security.*;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.HashMap;import java.util.Map;import javax.crypto.*;import java.io.*;public class Encryptor {private static final String KEY_FILENAME = “c:\\mykey.dat”;private static final String OTHERS_KEY_FILENAME = “c:\\Otherskey.dat”;// private static final int KEY_SIZE = 1024;// private static final int BLOCK_SIZE = 117;// private static final int OUTPUT_BLOCK_SIZE = 128;private static final int KEY_SIZE = 2048; //RSA key 是多少位的private static final int BLOCK_SIZE = 245; //一次RSA加密操作所允許的最大長度//這個值與 KEY_SIZE 已經padding方法有關。因為 1024的key的輸出是128，2048key輸出是256位元組//可能11個位元組用於保存padding信息了，所以最多可用的就只有245位元組了。private static final int OUTPUT_BLOCK_SIZE = 256;private SecureRandom secrand;private Cipher rsaCipher;private KeyPair keys;private MapString, Key allUserKeys;public Encryptor() throws Exception {try {allUserKeys = new HashMapString, Key();secrand = new SecureRandom();//SunJCE Provider 中只支持ECB mode，試了一下只有PKCS1PADDING可以直接還原原始數據，//NOPadding導致解壓出來的都是blocksize長度的數據，還要自己處理//參見 另外根據 Open-JDK-6.b17-src（ ）// 中代碼的注釋，使用RSA來加密大量數據不是一種標準的用法。所以現有實現一次doFinal調用之進行一個RSA操作，//如果用doFinal來加密超過的一個操作所允許的長度數據將拋出異常。//根據keysize的長度，典型的1024個長度的key和PKCS1PADDING一起使用時//一次doFinal調用只能加密117個byte的數據。（NOPadding 和1024 keysize時128個位元組長度）//（2048長度的key和PKCS1PADDING 最多允許245位元組一次）//想用來加密大量數據的只能自己用其他辦法實現了。可能RSA加密速度比較慢吧，要用AES才行rsaCipher = Cipher.getInstance(“RSA/ECB/PKCS1PADDING”);} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();throw e;}ObjectInputStream in;try {in = new ObjectInputStream(new FileInputStream(KEY_FILENAME));} catch (FileNotFoundException e) {if (false == GenerateKeys()){throw e;}LoadKeys();return;}keys = (KeyPair) in.readObject();in.close();LoadKeys();}/** 生成自己的公鑰和私鑰*/private Boolean GenerateKeys() {try {KeyPairGenerator keygen = KeyPairGenerator.getInstance(“RSA”);// secrand = new SecureRandom();// sedSeed之後會造成 生成的密鑰都是一樣的// secrand.setSeed(“chatencrptor”.getBytes()); // 初始化隨機產生器//key長度至少512長度，不過好像說現在用2048才算比較安全的了keygen.initialize(KEY_SIZE, secrand); // 初始化密鑰生成器keys = keygen.generateKeyPair(); // 生成密鑰組AddKey(“me”, EncodeKey(keys.getPublic()));} catch (NoSuchAlgorithmException e) {e.printStackTrace();return false;}ObjectOutputStream out;try {out = new ObjectOutputStream(new FileOutputStream(KEY_FILENAME));} catch (IOException e) {e.printStackTrace();return false;}try {out.writeObject(keys);} catch (IOException e) {e.printStackTrace();return false;} finally {try {out.close();} catch (IOException e) {e.printStackTrace();return false;}}return true;}public String EncryptMessage(String toUser, String Message) throws IOException {Key pubkey = allUserKeys.get(toUser);if ( pubkey == null ){throw new IOException(“NoKeyForThisUser”) ;}try {//PublicKey pubkey = keys.getPublic();rsaCipher.init(Cipher.ENCRYPT_MODE, pubkey, secrand);//System.out.println(rsaCipher.getBlockSize()); 返回0，非block 加密演算法來的？//System.out.println(Message.getBytes(“utf-8”).length);//byte[] encryptedData = rsaCipher.doFinal(Message.getBytes(“utf-8”));byte[] data = Message.getBytes(“utf-8”);int blocks = data.length / BLOCK_SIZE ;int lastBlockSize = data.length % BLOCK_SIZE ;byte [] encryptedData = new byte[ (lastBlockSize == 0 ? blocks : blocks + 1)* OUTPUT_BLOCK_SIZE];for (int i=0; i blocks; i++){//int thisBlockSize = ( i + 1 ) * BLOCK_SIZE data.length ? data.length – i * BLOCK_SIZE : BLOCK_SIZE ;rsaCipher.doFinal(data,i * BLOCK_SIZE, BLOCK_SIZE, encryptedData ,i * OUTPUT_BLOCK_SIZE);}if (lastBlockSize != 0 ){rsaCipher.doFinal(data, blocks * BLOCK_SIZE, lastBlockSize,encryptedData ,blocks * OUTPUT_BLOCK_SIZE);}//System.out.println(encrypted.length); 如果要機密的數據不足128/256位元組，加密後補全成為變為256長度的。//數量比較小時，Base64.GZIP產生的長度更長，沒什麼優勢//System.out.println(Base64.encodeBytes(encrypted,Base64.GZIP).length());//System.out.println(Base64.encodeBytes(encrypted).length());//System.out.println (rsaCipher.getOutputSize(30));//這個getOutputSize 只對 輸入小於最大的block時才能得到正確的結果。其實就是補全 數據為128/256 位元組return Base64.encodeBytes(encryptedData);} catch (InvalidKeyException e) {e.printStackTrace();throw new IOException(“InvalidKey”) ;}catch (ShortBufferException e) {e.printStackTrace();throw new IOException(“ShortBuffer”) ;}catch (UnsupportedEncodingException e) {e.printStackTrace();throw new IOException(“UnsupportedEncoding”) ;} catch (IllegalBlockSizeException e) {e.printStackTrace();throw new IOException(“IllegalBlockSize”) ;} catch (BadPaddingException e) {e.printStackTrace();throw new IOException(“BadPadding”) ;}finally {//catch 中 return 或者throw之前都會先調用一下這裡}}public String DecryptMessage(String Message) throws IOException {byte[] decoded = Base64.decode(Message);PrivateKey prikey = keys.getPrivate();try {rsaCipher.init(Cipher.DECRYPT_MODE, prikey, secrand);int blocks = decoded.length / OUTPUT_BLOCK_SIZE;ByteArrayOutputStream decodedStream = new ByteArrayOutputStream(decoded.length);for (int i =0 ;i blocks ; i ++ ){decodedStream.write (rsaCipher.doFinal(decoded,i * OUTPUT_BLOCK_SIZE, OUTPUT_BLOCK_SIZE));}return new String(decodedStream.toByteArray(), “UTF-8”);} catch (InvalidKeyException e) {e.printStackTrace();throw new IOException(“InvalidKey”);} catch (UnsupportedEncodingException e) {e.printStackTrace();throw new IOException(“UnsupportedEncoding”);} catch (IllegalBlockSizeException e) {e.printStackTrace();throw new IOException(“IllegalBlockSize”);} catch (BadPaddingException e) {e.printStackTrace();throw new IOException(“BadPadding”);} finally {// catch 中 return 或者throw之前都會先調用一下這裡。}}public boolean AddKey(String user, String key) {PublicKey publickey;try {publickey = DecodePublicKey(key);} catch (Exception e) {return false;}allUserKeys.put(user, publickey);SaveKeys();return true;}private boolean LoadKeys() {BufferedReader input;try {input = new BufferedReader(new InputStreamReader(new FileInputStream(OTHERS_KEY_FILENAME)));} catch (FileNotFoundException e1) {// e1.printStackTrace();return false;}

RSA PKCS#1在java中怎麼實現？

樓主看看下面的代碼是不是你所需要的，這是我原來用的時候收集的

import javax.crypto.Cipher;

import java.security.*;

import java.security.spec.RSAPublicKeySpec;

import java.security.spec.RSAPrivateKeySpec;

import java.security.spec.InvalidKeySpecException;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.io.*;

import java.math.BigInteger;

/**

* RSA 工具類。提供加密，解密，生成密鑰對等方法。

* 需要到下載bcprov-jdk14-123.jar。

* 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)

* ===================================================================

* 加解密方法：

* 1.首先將要加密的信息 m(二進位表示) 分成等長的數據塊 m1,m2,…,mi 塊長 s(儘可能大) ,其中 2^sn

* 2:對應的密文是： ci = mi^e(mod n)

* 3:解密時作如下計算： mi = ci^d(mod n)

* ===================================================================

* RSA速度

* 由於進行的都是大數計算，使得RSA最快的情況也比DES慢上100倍，無論是軟體還是硬體實現。

* 速度一直是RSA的缺陷。一般來說只用於少量數據加密。

* 文件名：RSAUtil.javabr

* @author 趙峰br

* 版本:1.0.1br

* 描述：本演算法摘自網路，是對RSA演算法的實現br

* 創建時間:2009-7-10 下午09:58:16br

* 文件描述：首先生成兩個大素數，然後根據Euclid演算法生成解密密鑰br

*/

public class RSAUtil {

//密鑰對

private KeyPair keyPair = null;

/**

* 初始化密鑰對

*/

public RSAUtil(){

try {

this.keyPair = this.generateKeyPair();

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 生成密鑰對

* @return KeyPair

* @throws Exception

*/

private KeyPair generateKeyPair() throws Exception {

try {

KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(“RSA”,new org.bouncycastle.jce.provider.BouncyCastleProvider());

//這個值關係到塊加密的大小，可以更改，但是不要太大，否則效率會低

final int KEY_SIZE = 1024;

keyPairGen.initialize(KEY_SIZE, new SecureRandom());

KeyPair keyPair = keyPairGen.genKeyPair();

return keyPair;

} catch (Exception e) {

throw new Exception(e.getMessage());

}

}

/**

* 生成公鑰

* @param modulus

* @param publicExponent

* @return RSAPublicKey

* @throws Exception

*/

private RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) throws Exception {

KeyFactory keyFac = null;

try {

keyFac = KeyFactory.getInstance(“RSA”, new org.bouncycastle.jce.provider.BouncyCastleProvider());

} catch (NoSuchAlgorithmException ex) {

throw new Exception(ex.getMessage());

}

RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(modulus), new BigInteger(publicExponent));

try {

return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);

} catch (InvalidKeySpecException ex) {

throw new Exception(ex.getMessage());

}

}

/**

* 生成私鑰

* @param modulus

* @param privateExponent

* @return RSAPrivateKey

* @throws Exception

*/

private RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) throws Exception {

KeyFactory keyFac = null;

try {

keyFac = KeyFactory.getInstance(“RSA”, new org.bouncycastle.jce.provider.BouncyCastleProvider());

} catch (NoSuchAlgorithmException ex) {

throw new Exception(ex.getMessage());

}

RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(privateExponent));

try {

return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);

} catch (InvalidKeySpecException ex) {

throw new Exception(ex.getMessage());

}

}

/**

* 加密

* @param key 加密的密鑰

* @param data 待加密的明文數據

* @return 加密後的數據

* @throws Exception

*/

public byte[] encrypt(Key key, byte[] data) throws Exception {

try {

Cipher cipher = Cipher.getInstance(“RSA”, new org.bouncycastle.jce.provider.BouncyCastleProvider());

cipher.init(Cipher.ENCRYPT_MODE, key);

// 獲得加密塊大小，如:加密前數據為128個byte，而key_size=1024 加密塊大小為127 byte,加密後為128個byte;

// 因此共有2個加密塊，第一個127 byte第二個為1個byte

int blockSize = cipher.getBlockSize();

// System.out.println(“blockSize:”+blockSize);

int outputSize = cipher.getOutputSize(data.length);// 獲得加密塊加密後塊大小

// System.out.println(“加密塊大小：”+outputSize);

int leavedSize = data.length % blockSize;

// System.out.println(“leavedSize:”+leavedSize);

int blocksSize = leavedSize != 0 ? data.length / blockSize + 1 : data.length / blockSize;

byte[] raw = new byte[outputSize * blocksSize];

int i = 0;

while (data.length – i * blockSize 0) {

if (data.length – i * blockSize blockSize)

cipher.doFinal(data, i * blockSize, blockSize, raw, i * outputSize);

else

cipher.doFinal(data, i * blockSize, data.length – i * blockSize, raw, i * outputSize);

// 這裡面doUpdate方法不可用，查看源代碼後發現每次doUpdate後並沒有什麼實際動作除了把byte[]放到ByteArrayOutputStream中

// 而最後doFinal的時候才將所有的byte[]進行加密，可是到了此時加密塊大小很可能已經超出了OutputSize所以只好用dofinal方法。

i++;

}

return raw;

} catch (Exception e) {

throw new Exception(e.getMessage());

}

}

/**

* 解密

* @param key 解密的密鑰

* @param raw 已經加密的數據

* @return 解密後的明文

* @throws Exception

*/

@SuppressWarnings(“static-access”)

public byte[] decrypt(Key key, byte[] raw) throws Exception {

try {

Cipher cipher = Cipher.getInstance(“RSA”, new org.bouncycastle.jce.provider.BouncyCastleProvider());

cipher.init(cipher.DECRYPT_MODE, key);

int blockSize = cipher.getBlockSize();

ByteArrayOutputStream bout = new ByteArrayOutputStream(64);

int j = 0;

while (raw.length – j * blockSize 0) {

bout.write(cipher.doFinal(raw, j * blockSize, blockSize));

j++;

}

return bout.toByteArray();

} catch (Exception e) {

throw new Exception(e.getMessage());

}

}

/**

* 返回公鑰

* @return

* @throws Exception

*/

public RSAPublicKey getRSAPublicKey() throws Exception{

//獲取公鑰

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

//獲取公鑰係數(位元組數組形式)

byte[] pubModBytes = pubKey.getModulus().toByteArray();

//返回公鑰公用指數(位元組數組形式)

byte[] pubPubExpBytes = pubKey.getPublicExponent().toByteArray();

//生成公鑰

RSAPublicKey recoveryPubKey = this.generateRSAPublicKey(pubModBytes,pubPubExpBytes);

return recoveryPubKey;

}

/**

* 獲取私鑰

* @return

* @throws Exception

*/

public RSAPrivateKey getRSAPrivateKey() throws Exception{

// 獲取私鑰

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

// 返回私鑰係數(位元組數組形式)

byte[] priModBytes = priKey.getModulus().toByteArray();

// 返回私鑰專用指數(位元組數組形式)

byte[] priPriExpBytes = priKey.getPrivateExponent().toByteArray();

// 生成私鑰

RSAPrivateKey recoveryPriKey = this.generateRSAPrivateKey(priModBytes,priPriExpBytes);

return recoveryPriKey;

}

/**

* 測試

* @param args

* @throws Exception

*/

public static void main(String[] args) throws Exception {

RSAUtil rsa = new RSAUtil();

String str = “天龍八部、神鵰俠侶、射鵰英雄傳白馬嘯西風”;

RSAPublicKey pubKey = rsa.getRSAPublicKey();

RSAPrivateKey priKey = rsa.getRSAPrivateKey();

// System.out.println(“加密後==” + new String(rsa.encrypt(pubKey,str.getBytes())));

String mw = new String(rsa.encrypt(pubKey, str.getBytes()));

System.out.println(“加密後：”+mw);

// System.out.println(“解密後：”);

System.out.println(“解密後==” + new String(rsa.decrypt(priKey,rsa.encrypt(pubKey,str.getBytes()))));

}

}

請高手指教如何用java編寫RSA演算法？謝謝

你是用rsa演算法去加密，還是要自己編寫一個rsa演算法？

RSA是非對稱加密演算法，可以用它通過KeyPairGenerator來生成KeyPari，它裡面有公鑰和私鑰。

通過Cipher.getInstance(“PBEWithMD5AndDES”)得到Cipher對象並初始化為加密/解密模式。最doFinal即可完成加解密。除了生成KeyPari外，還可以通過RSA演算法的證書和密鑰庫來得到公/私鑰。如果閣下想自己編寫一個RSA演算法的，本人就無能為力了。

如何用java實現128位密鑰的RSA演算法

 import javax.crypto.Cipher;

 import sun.misc.BASE64Decoder;

 import sun.misc.BASE64Encoder;

 import java.io.FileInputStream;

 import java.io.FileOutputStream;

 import java.io.ObjectInputStream;

 import java.io.ObjectOutputStream;

 import java.security.Key;

 import java.security.KeyPair;

 import java.security.KeyPairGenerator;

import java.security.SecureRandom;

 public class RSA_Encrypt {

 /** 指定加密演算法為DESede */

 private static String ALGORITHM = “RSA”;

 /** 指定key的大小 */

 private static int KEYSIZE = 128;

 /** 指定公鑰存放文件 */

 private static String PUBLIC_KEY_FILE = “PublicKey”;

 /** 指定私鑰存放文件 */

 private static String PRIVATE_KEY_FILE = “PrivateKey”;

// private static String PUBLIC_KEY_FILE = “D://PublicKey.a”;

// private static String PRIVATE_KEY_FILE = “D://PrivateKey.a”;

 /**

 * 生成密鑰對

 */

 private static void generateKeyPair() throws Exception{

   /** RSA演算法要求有一個可信任的隨機數源 */

    SecureRandom sr = new SecureRandom();

    /** 為RSA演算法創建一個KeyPairGenerator對象 */

    KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITHM);

   /** 利用上面的隨機數據源初始化這個KeyPairGenerator對象 */

    kpg.initialize(KEYSIZE, sr);

    /** 生成密匙對 */

    KeyPair kp = kpg.generateKeyPair();

    /** 得到公鑰 */

    Key publicKey = kp.getPublic();

    /** 得到私鑰 */

    Key privateKey = kp.getPrivate();

    /** 用對象流將生成的密鑰寫入文件 */

    ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream(PUBLIC_KEY_FILE));

    ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream(PRIVATE_KEY_FILE));

    oos1.writeObject(publicKey);

    oos2.writeObject(privateKey);

    /** 清空緩存，關閉文件輸出流 */

    oos1.close();

    oos2.close();

 }

 /**

 * 加密方法

 * source： 源數據

 */

 public static String encrypt(String source) throws Exception{

    generateKeyPair();

    /** 將文件中的公鑰對象讀出 */

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PUBLIC_KEY_FILE));

    Key key = (Key) ois.readObject();

    ois.close();

    /** 得到Cipher對象來實現對源數據的RSA加密 */

    Cipher cipher = Cipher.getInstance(ALGORITHM);

    cipher.init(Cipher.ENCRYPT_MODE, key);

    byte[] b = source.getBytes();

    /** 執行加密操作 */

    byte[] b1 = cipher.doFinal(b);

    BASE64Encoder encoder = new BASE64Encoder();

    return encoder.encode(b1);

 }

 /**

 * 解密演算法

 * cryptograph:密文

 */

 public static String decrypt(String cryptograph) throws Exception{

    /** 將文件中的私鑰對象讀出 */

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PRIVATE_KEY_FILE));

    Key key = (Key) ois.readObject();

    /** 得到Cipher對象對已用公鑰加密的數據進行RSA解密 */

    Cipher cipher = Cipher.getInstance(ALGORITHM);

    cipher.init(Cipher.DECRYPT_MODE, key);

    BASE64Decoder decoder = new BASE64Decoder();

    byte[] b1 = decoder.decodeBuffer(cryptograph);

    /** 執行解密操作 */

    byte[] b = cipher.doFinal(b1);

    return new String(b);

 }

 public static void main(String[] args) {

  try {

   String source = “Hello World!”;//要加密的字元串

   String cryptograph = encrypt(source);

   System.out.println(cryptograph);

   String target = decrypt(cryptograph);//解密密文

   System.out.println(target);

  } catch (Exception e) {

   // TODO Auto-generated catch block

   e.printStackTrace();

  }//生成的密文

 }

}