RSA算法原理與具體實現

1. 什么是RSA

RSA算法是現今使用最廣泛的公鑰密碼算法，也是號稱地球上最安全的加密算法。在了解RSA算法之前，先熟悉下幾個術語 根據密鑰的使用方法，可以將密碼分為對稱密碼和公鑰密碼 對稱密碼：加密和解密使用同一種密鑰的方式

公鑰密碼：加密和解密使用不同的密碼的方式，因此公鑰密碼通常也稱為非對稱密碼。

2. RSA加密

RSA的加密過程可以使用一個通式來表達

密文＝明文EmodN

也就是說RSA加密是對明文的E次方后除以N后求余數的過程。就這么簡單？對，就是這么簡單。 從通式可知，只要知道E和N任何人都可以進行RSA加密了，所以說E、N是RSA加密的密鑰，也就是說E和N的組合就是公鑰，我們用(E,N)來表示公鑰

公鑰＝(E,N)

不過E和N不並不是隨便什么數都可以的，它們都是經過嚴格的數學計算得出的，關於E和N擁有什么樣的要求及其特性后面會講到。順便啰嗦一句E是加密（Encryption）的首字母，N是數字（Number）的首字母

3. RSA解密

RSA的解密同樣可以使用一個通式來表達

明文＝密文DmodN

也就是說對密文進行D次方后除以N的余數就是明文，這就是RSA解密過程。知道D和N就能進行解密密文了，所以D和N的組合就是私鑰

私鑰＝(D,N)

從上述可以看出RSA的加密方式和解密方式是相同的，加密是求“E次方的mod N”;解密是求“D次方的mod N” 此處D是解密（Decryption）的首字母；N是數字（Number）的首字母。

公鑰 （E，N）
私鑰 （D，N）
密鑰對 （E，D，N）
加密 密文＝明文EmodN密文＝明文EmodN 解密 明文＝密文DmodN

4. 生成密鑰對

既然公鑰是（E，N），私鑰是（D，N）所以密鑰對即為（E，D，N）但密鑰對是怎樣生成的？步驟如下：

1. 求N
2. 求L（L為中間過程的中間數）
3. 求E
4. 求D

4.1 求N

准備兩個質數p，q。這兩個數不能太小，太小則會容易破解，將p乘以q就是N

N=p∗q

4.2 求L

L 是 p－1 和 q－1的最小公倍數，可用如下表達式表示

L=（p－1，q－1）

4.3 求E

E必須滿足兩個條件：E是一個比1大比L小的數，E和L的最大公約數為1 用gcd(X,Y)來表示X，Y的最大公約數則E條件如下：

1 < E < L gcd（E，L）=1 

之所以需要E和L的最大公約數為1是為了保證一定存在解密時需要使用的數D。現在我們已經求出了E和N也就是說我們已經生成了密鑰對中的公鑰了。

4.4 求D

數D是由數E計算出來的。D、E和L之間必須滿足以下關系：

1 < D < L E＊D mod L ＝ 1 

只要D滿足上述2個條件，則通過E和N進行加密的密文就可以用D和N進行解密。 簡單地說條件2是為了保證密文解密后的數據就是明文。 現在私鑰自然也已經生成了，密鑰對也就自然生成了。 小結下：

求N N＝ p ＊ q ；p，q為質數
求L L＝lcm（p－1，q－1） ；L為p－1、q－1的最小公倍數
求E 1 < E < L，gcd（E，L）=1；E，L最大公約數為1（E和L互質） 求D 1 < D < L，E＊D mod L ＝ 1

5 實踐下吧

我們用具體的數字來實踐下RSA的密鑰對對生成，及其加解密對全過程。為方便我們使用較小數字來模擬。

5.1 求N 我們准備兩個很小對質數， p ＝ 17 q ＝ 19 N ＝ p ＊ q ＝ 323

5.2 求L L ＝ lcm（p－1， q－1）＝ lcm(16，18） ＝ 144 144為16和18對最小公倍數

5.3 求E 求E必須要滿足2個條件：1 < E < L ，gcd（E，L）=1 即1 < E < 144，gcd（E，144） ＝ 1 E和144互為質數，5顯然滿足上述2個條件 故E ＝ 5

此時公鑰=(E，N）＝ （5，323）

5.4 求D 求D也必須滿足2個條件：1 < D < L，E＊D mod L ＝ 1 即1 < D < 144，5 ＊ D mod 144 ＝ 1 顯然當D＝ 29 時滿足上述兩個條件 1 < 29 < 144 5＊29 mod 144 ＝ 145 mod 144 ＝ 1 此時私鑰＝（D，N）＝（29，323）

5.5 加密 准備的明文必須時小於N的數，因為加密或者解密都要mod N其結果必須小於N 假設明文 ＝ 123 則 密文＝明文EmodN＝1235mod323=225密文＝明文EmodN＝1235mod323=225 5.6 解密 明文＝密文DmodN＝22529mod323=123明文＝密文DmodN＝22529mod323=123 解密后的明文為123

6 實現RSA算法

import com.sun.org.apache.xml.internal.security.utils.Base64;
import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * RSA
 * 非對稱加解密
 * 算法實現
 */
public class RSAEncrypt {

    /**
     * 緩存公鑰與私鑰組
     */
    private static Map<String, Object> keyMap = new HashMap<>();

    /**
     * 隨機生成密鑰對
     * @throws NoSuchAlgorithmException
     */
    public static String genKeyPair() throws NoSuchAlgorithmException {
        // KeyPairGenerator類用於生成公鑰和私鑰對，基於RSA算法生成對象
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
        // 初始化密鑰對生成器，密鑰大小為96-1024位
        keyPairGen.initialize(1024,new SecureRandom());
        // 生成一個密鑰對，保存在keyPair中
        KeyPair keyPair = keyPairGen.generateKeyPair();
        // 得到公鑰
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        // 得到私鑰
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        String strPublicKey = new String(Base64.encode(publicKey.getEncoded()));
        // 將公鑰和私鑰保存到Map
        keyMap.put(strPublicKey,privateKey);
        return strPublicKey;
    }

    /**
     * RSA公鑰加密
     *
     * @param str
     *        加密字符串
     * @param publicKey
     *        公鑰
     * @return 密文
     * @throws Exception
     *        加密過程中的異常信息
     */
    public static String encrypt( String str, String publicKey ) throws Exception{
        //base64編碼的公鑰
        byte[] decoded = Base64.decode(publicKey);
        RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
        //RSA加密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        String outStr = Base64.encode(cipher.doFinal(str.getBytes("UTF-8")));
        return outStr;
    }

    /**
     * RSA私鑰解密
     *
     * @param str
     *            加密字符串
     * @param privateKey
     *            私鑰
     * @return 銘文
     * @throws Exception
     *             解密過程中的異常信息
     */
    public static String decrypt(String str, String privateKey) throws Exception{
        //64位解碼加密后的字符串
        byte[] inputByte = Base64.decode(str.getBytes("UTF-8"));
        //base64編碼的私鑰
        byte[] decoded = Base64.decode(privateKey);
        RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
        //RSA解密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, priKey);
        String outStr = new String(cipher.doFinal(inputByte));
        return outStr;
    }

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

        //生成公鑰和私鑰
        genKeyPair();
        //加密字符串
        String message = "df723820";
        String strPublicKey = genKeyPair();
        System.out.println("隨機生成的公鑰為:" + strPublicKey);

        Object privatePair = keyMap.get(strPublicKey);
        RSAPrivateKey privateKey = (RSAPrivateKey) privatePair;
        String strPrivateKey = new String(Base64.encode((privateKey.getEncoded())));

        System.out.println("隨機生成的私鑰為:" + strPrivateKey);
        String messageEn = encrypt(message,strPublicKey);

        System.out.println(message + "\t加密后的字符串為:" + messageEn);
        String messageDe = decrypt(messageEn,strPrivateKey);
        System.out.println("還原后的字符串為:" + messageDe);

    }

}