簡單實現RAS加密-java

簡單實現RSA加密

理論基礎

實現RSA的算法需要一部分數學基礎。

互質概念

如果兩個正整數，除了1以外，沒有其他公因子，我們就稱這兩個數是互質關係（coprime）。比如，15和32沒有公因子，所以它們是互質關係。這說明，不是質數也可以構成互質關係。

關於互質關係，不難得到以下結論：

　　1. 任意兩個質數構成互質關係，比如13和61。

　　2. 一個數是質數，另一個數只要不是前者的倍數，兩者就構成互質關係，比如3和10。

　　3. 如果兩個數之中，較大的那個數是質數，則兩者構成互質關係，比如97和57。

　　4. 1和任意一個自然數是都是互質關係，比如1和99。

　　5. p是大於1的整數，則p和p-1構成互質關係，比如57和56。

　　6. p是大於1的奇數，則p和p-2構成互質關係，比如17和15。

歐拉函數和歐拉定理

任意給定正整數n，請問在小於等於n的正整數之中，有多少個與n構成互質關係？（比如，在1到8之中，有多少個數與8構成互質關係？）
計算這個值的方法就叫做歐拉函數，以φ(n)表示。在1到8之中，與8形成互質關係的是1、3、5、7，所以 φ(n) = 4。

歐拉函數的用處，在於歐拉定理。”歐拉定理”指的是：
如果兩個正整數a和n互質，則n的歐拉函數 φ(n) 可以讓下面的等式成立。a的φ(n)次方被n除的餘數爲1。或者說，a的φ(n)次方減去1，可以被n整除。比如，3和7互質，而7的歐拉函數φ(7)等於6，所以3的6次方（729）減去1，可以被7整除（728/7=104）。

模反元素

如果兩個正整數a和n互質，那麼一定可以找到整數b，使得 ab-1 被n整除，或者說ab被n除的餘數是1。這時，b就叫做a的”模反元素”。

RSA的簡單實現

第一步，隨機選擇兩個不相等的質數p和q。

第二步，計算p和q的乘積n。

第三步，計算n的歐拉函數φ(n)。
根據公式：

φ(n) = (p-1)(q-1)

第四步，隨機選擇一個整數e，條件是1< e < φ(n)，且e與φ(n) 互質。

第五步，計算e對於φ(n)的模反元素d。
根據公式：

ed - 1 = kφ(n)

這個方程可以用”擴展歐幾里得算法”求解，此處省略具體過程。

第六步，將n和e封裝成公鑰，n和d封裝成私鑰。

加密和解密

有了公鑰和密鑰，就能進行加密和解密了。

加密要用公鑰 (n,e)，所謂”加密”，就是算出下式的c：

me ≡ c (mod n)

解密要用私鑰(n,d)，通過已知的c算出m：

cd ≡ m (mod n)

至此，”加密–解密”的整個過程全部完成。

代碼

package etc;

import java.util.Random;

/**
 * 簡單實現RAS加密
 * Created by Administrator on 2018/2/2.
 */
public class RSASimple {
    public static void main(String[] args) {
        buildN();
        buildD(E,faiN);
        while (d<=1){
            buildN();
            buildD(E,faiN);
        }

        System.out.println("public:"+N+","+E);
        System.out.println("private:"+N+","+d);


        long message=RSASimpleBoxing(65);
        System.out.println(message);
        System.out.println(RSASimpleReboxing(message));
    }


    //加密
    public static long RSASimpleBoxing(long m){
        long c= 1;
        for(int i=0;i<E;i++){
            c*=m;
            if(c>N)
                c%=N;
        }
        return c;
    }

    //解密
    public static long RSASimpleReboxing(long c){
        long m=1;
        for(int i=0;i<d;i++){
            m*=c;
            if(m>N)
                m%=N;
        }
        return m;
    }

    //測試數據
    public static final int E=17;
    public static long p=61;
    public static long q=53;
    public static long N=3233;
    public static long faiN=3120;
    public static long d=2753;

    //隨機生成p,q
    public static void buildN(){
        Random r=new Random();
        int[] primeArr=new int[100];
        int temp=2,num=0;
        while (num!=100){
            if(isPrime(temp)){
                primeArr[num]=temp;
                num++;
            }
            temp++;
        }
        p= primeArr[r.nextInt(100)];
        q= primeArr[r.nextInt(100)];

        while (p==q){
            q=primeArr[r.nextInt(100)];
        }

        N= p*q;
        faiN=(p-1)*(q-1);
//        System.out.println(p+" "+q+" "+N+" "+faiN);
    }

    //計算d
    public static void buildD(long E,long faiN){
        long[] result=extend_gcd(E,faiN);
        d=result[1];
    }

    //判斷素數
    public static boolean isPrime(long n){
        if(n<=1)return false;
        else if(n==2)return true;
        else if(n==4)return false;
        for(int i=2;i<n/2;i++){
            if(n%i==0){
                return false;
            }
        }
        return true;
    }


    //擴展歐幾里得算法，已知ab求解xy
    //返回的數組中，第一個值是最大公約數，第二個值表示C++語言實現中的x，第三個值表示y。
    //TODO:這個算法會讓生成的d爲負數，造成解密失敗
    public static long[] extend_gcd(long a,long b){
        long ans;
        long[] result=new long[3];
        if(b==0)
        {
            result[0]=a;
            result[1]=1;
            result[2]=0;
            return result;
        }
        long [] temp=extend_gcd(b,a%b);
        ans = temp[0];
        result[0]=ans;
        result[1]=temp[2];
        result[2]=temp[1]-(a/b)*temp[2];
        return result;
    }

}

參考博文：
http://www.ruanyifeng.com/blog/2013/06/rsa_algorithm_part_one.html
http://www.ruanyifeng.com/blog/2013/07/rsa_algorithm_part_two.html
http://blog.csdn.net/zhjchengfeng5/article/details/7786595