简单实现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