自己實現簡單的RSA秘鑰生成與加解密(Java )

　  最近在學習PKI，順便接觸了一些加密算法。對RSA着重研究了一下，自己也寫了一個簡單的實現RSA算法的Demo，包括公、私鑰生成，加解密的實現。雖然比較簡單，但是也大概囊括了RSA加解密的核心思想與流程。這里寫下來與大家分享一下。                                                                                                                                              

　　RSA概述：

　　　RSA是目前最有影響力的公鑰加密算法，它能夠抵抗到目前為止已知的絕大多數密碼攻擊，已被ISO推薦為公鑰數據加密標准。 RSA的數學基礎是大整數因子分解問題，其說明如下：

• 給定兩個素數p、q，計算乘積pq=n很容易

• 給定整數n，求n的素因數p、q使得n=pq十分困難

 

　　RSA的密碼體制:

　　 設n=pq,其中p和q是大素數。設P=E=Z_n，且定義K={（n,p,q,a,b）:ab≡1(modΦ(n)) }其中 Φ(n)=(p-1)(q-1)。對於K={(n,p,q,a,b)} 定義加密 E（x）=x^b mod n; 解密D(y)=y^a mod n;(x,y∈Z_n),值n,b組成了公鑰，p、q和a組成了私鑰

•  RSA生成秘鑰步驟　　　

1. 隨機生成兩個大素數p、q,並計算他們的乘積n
2. 計算k=(p-1)(q-1)
3. 生成一個小於k且與k互質的數b，一般可使用65537
4. 通過擴展歐幾里得算法求出a關於k的反模a。

　　代碼如下：

首先，寫出三個封裝類，PrivateKey.java PublicKey.java RsaKeyPair.java (JDK中的實現高度抽象，這里我們就簡單的封裝一下)　　

package com.khalid.pki;

import java.math.BigInteger;

public class PublicKey {

    private final BigInteger n;
    
    private final BigInteger b;
    
    public PublicKey(BigInteger n,BigInteger b){
        this.n=n;
        this.b=b;
    }

    public BigInteger getN() {
        return n;
    }

    public BigInteger getB() {
        return b;
    }
}

package com.khalid.pki;

import java.math.BigInteger;

public class PrivateKey {

    private final BigInteger n;
    
    private final BigInteger a;
    
    public PrivateKey(BigInteger n,BigInteger a){
        this.n=n;
        this.a=a;
    }

    public BigInteger getN() {
        return n;
    }

    public BigInteger getA() {
        return a;
    }
}

package com.khalid.pki;

public class RsaKeyPair {

    private final PrivateKey privateKey;
    
    private final PublicKey publicKey;
    
    public RsaKeyPair(PublicKey publicKey,PrivateKey privateKey){
        this.privateKey=privateKey;
        this.publicKey=publicKey;
    }

    public PrivateKey getPrivateKey() {
        return privateKey;
    }

    public PublicKey getPublicKey() {
        return publicKey;
    }
}

 

 生成大素數的方法沒有自己實現，借用了BigInteger類中的probablePrime(int bitlength,SecureRandom random)方法

 

SecureRandom random=new SecureRandom();
random.setSeed(new Date().getTime());
BigInteger bigPrimep,bigPrimeq;
while(!(bigPrimep=BigInteger.probablePrime(bitlength,random)).isProbablePrime(1)){
            continue;
        }//生成大素數p
        
while(!(bigPrimeq=BigInteger.probablePrime(bitlength,random)).isProbablePrime(1)){
            continue;
        }//生成大素數q

 

計算k、n、b的值

BigInteger n=bigPrimep.multiply(bigPrimeq);//生成n
        //生成k
BigInteger k=bigPrimep.subtract(BigInteger.ONE).multiply(bigPrimeq.subtract(BigInteger.ONE));
        //生成一個比k小的b,或者使用65537
BigInteger b=BigInteger.probablePrime(bitlength-1, random);

 

核心計算a的值，擴展歐幾里得算法如下

　　注意第二個方法 cal 其實還可以傳遞第三個參數，模的值，但是我們這里省略了這個參數，因為在RSA中模是1

    private static BigInteger x; //存儲臨時的位置變量x，y 用於遞歸
    
    private static BigInteger y;
    
    
    //歐幾里得擴展算法
    public static BigInteger ex_gcd(BigInteger a,BigInteger b){
        if(b.intValue()==0){
            x=new BigInteger("1");
            y=new BigInteger("0");
            return a;
        }
        BigInteger ans=ex_gcd(b,a.mod(b));
        BigInteger temp=x;
        x=y;
        y=temp.subtract(a.divide(b).multiply(y));
        return ans;
        
    }
    
    //求反模 
    public static BigInteger cal(BigInteger a,BigInteger k){
        BigInteger gcd=ex_gcd(a,k);
        if(BigInteger.ONE.mod(gcd).intValue()!=0){
            return new BigInteger("-1");
        }
        //由於我們只求乘法逆元 所以這里使用BigInteger.One,實際中如果需要更靈活可以多傳遞一個參數,表示模的值來代替這里
        x=x.multiply(BigInteger.ONE.divide(gcd));
        k=k.abs();
        BigInteger ans=x.mod(k);
        if(ans.compareTo(BigInteger.ZERO)<0) ans=ans.add(k);
        return ans;
        
    }

 我們在生成中只需要

  BigInteger a=cal(b,k); 

就可以在Log級別的時間內計算出a的值

將以上代碼結合包裝成的 RSAGeneratorKey.java

package com.khalid.pki;

import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.Date;

public class RSAGeneratorKey {
    
    private static BigInteger x; //存儲臨時的位置變量x，y 用於遞歸
    
    private static BigInteger y;
    
    
    //歐幾里得擴展算法
    public static BigInteger ex_gcd(BigInteger a,BigInteger b){
        if(b.intValue()==0){
            x=new BigInteger("1");
            y=new BigInteger("0");
            return a;
        }
        BigInteger ans=ex_gcd(b,a.mod(b));
        BigInteger temp=x;
        x=y;
        y=temp.subtract(a.divide(b).multiply(y));
        return ans;
        
    }
    
    //求反模 
    public static BigInteger cal(BigInteger a,BigInteger k){
        BigInteger gcd=ex_gcd(a,k);
        if(BigInteger.ONE.mod(gcd).intValue()!=0){
            return new BigInteger("-1");
        }
        //由於我們只求乘法逆元 所以這里使用BigInteger.One,實際中如果需要更靈活可以多傳遞一個參數,表示模的值來代替這里
        x=x.multiply(BigInteger.ONE.divide(gcd));
        k=k.abs();
        BigInteger ans=x.mod(k);
        if(ans.compareTo(BigInteger.ZERO)<0) ans=ans.add(k);
        return ans;
        
    }

    public static RsaKeyPair generatorKey(int bitlength){
        SecureRandom random=new SecureRandom();
        random.setSeed(new Date().getTime());
        BigInteger bigPrimep,bigPrimeq;
        while(!(bigPrimep=BigInteger.probablePrime(bitlength, random)).isProbablePrime(1)){
            continue;
        }//生成大素數p
        
        while(!(bigPrimeq=BigInteger.probablePrime(bitlength, random)).isProbablePrime(1)){
            continue;
        }//生成大素數q
        
        BigInteger n=bigPrimep.multiply(bigPrimeq);//生成n
        //生成k
        BigInteger k=bigPrimep.subtract(BigInteger.ONE).multiply(bigPrimeq.subtract(BigInteger.ONE));
        //生成一個比k小的b,或者使用65537
        BigInteger b=BigInteger.probablePrime(bitlength-1, random);
        //根據擴展歐幾里得算法生成b 
        BigInteger a=cal(b,k);
        //存儲入 公鑰與私鑰中
        PrivateKey privateKey=new PrivateKey(n, a);
        PublicKey  publicKey=new PublicKey(n, b);
        
        //生成秘鑰對 返回密鑰對
        return new RsaKeyPair(publicKey, privateKey);
    }
}

 

 編寫一個簡單的JUnit測試代碼，沒有把結果以字節流編碼顯示 ，比較懶。。。。

package com.khalid.pki;

import org.junit.Test;

public class RSATest {

    @Test
    public void testGeneratorKey(){
        RsaKeyPair keyPair=RSAGeneratorKey.generatorKey(256);
        System.out.println("n的值是:"+keyPair.getPublicKey().getN());
        System.out.println("公鑰b:"+keyPair.getPublicKey().getB());
        System.out.println("私鑰a:"+keyPair.getPrivateKey().getA());
    }
    

}

 

這樣秘鑰對的生成工作就完成了

 　加密與解密

　　加密與解密的根本就是使用E（x）=x^b mod n D(y)=y^a mod n這兩個公式，所以我們首先要將數據轉化為最底層的二進制串，在轉換為BigInteger進行計算，將結果做成Base64碼

代碼如下

package com.khalid.pki;

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.util.Arrays;

import org.apache.commons.codec.binary.Base64;

public class RSAUtil {

    public static String encrypt(String source,PublicKey key,String charset){
        byte[] sourceByte = null;
        try {
            sourceByte = source.getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        BigInteger temp=new BigInteger(1,sourceByte);
        BigInteger encrypted=temp.modPow(key.getB(), key.getN());
        return Base64.encodeBase64String(encrypted.toByteArray());
        }
    
    public static String decrypt(String cryptdata,PrivateKey key,String charset) throws UnsupportedEncodingException{
        byte[] byteTmp=Base64.decodeBase64(cryptdata);
        BigInteger cryptedBig=new BigInteger(byteTmp);
        byte[] cryptedData=cryptedBig.modPow(key.getA(), key.getN()).toByteArray();
        cryptedData=Arrays.copyOfRange(cryptedData, 1, cryptedData.length);//去除符號位的字節
        return new String(cryptedData,charset);
        
    }
}

 很坑爹的一點是要記得BigInteger是有符號位的。重組String時要記得去除符號位，不然中文的時候會莫名其妙在第一位多出空格。

在編寫一個測試代碼就Ok了

package com.khalid.pki;

import java.io.UnsupportedEncodingException;
import org.junit.Test;

public class RSATest {

    
    @Test
    public void testRSA() throws UnsupportedEncodingException{
        //生成KeyPair
        RsaKeyPair keyPair=RSAGeneratorKey.generatorKey(1024);
        // 元數據
        String source = new String("哈哈哈哈哈~~~嘿嘿嘿嘿嘿~~---呵呵呵呵呵！");

        System.out.println("加密前:"+source);
        //使用公鑰加密 
        String cryptdata=RSAUtil.encrypt(source, keyPair.getPublicKey(),"UTF-8");
        System.out.println("加密后:"+cryptdata);
        //使用私鑰解密
        try {
            String result=RSAUtil.decrypt(cryptdata, keyPair.getPrivateKey(),"UTF-8");
            System.out.println("解密后:"+result);
            System.out.println(result.equals(source));
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

測試結果。bingo。