RSA加密解密的实现详解_JAVA

这两天在看Android开发中用到的加密解密算法，就上网搜，找到了一些不错的文章，现和大家分享一下。今天分享的是非对称加密算法——RSA。

一、什么是Rsa加密？

RSA算法是最流行的公钥密码算法，使用长度可以变化的密钥。RSA是第一个既能用于数据加密也能用于数字签名的算法。

RSA算法原理如下：

1.随机选择两个大质数p和q，p不等于q，计算N=pq； 

2.选择一个大于1小于N的自然数e，e必须与(p-1)(q-1)互素。 

3.用公式计算出d：d×e = 1 (mod (p-1)(q-1)) 。

4.销毁p和q。

最终得到的N和e就是“公钥”，d就是“私钥”，发送方使用N去加密数据，接收方只有使用d才能解开数据内容。

RSA的安全性依赖于大数分解，小于1024位的N已经被证明是不安全的，而且由于RSA算法进行的都是大数计算，使得RSA最快的情况也比DES慢上倍，这是RSA最大的缺陷，因此通常只能用于加密少量数据或者加密密钥，但RSA仍然不失为一种高强度的算法。

二、该如何使用呢?

 首先生成秘钥对

/**     * 随机生成RSA密钥对     *     * @param keyLength 密钥长度，范围：512～2048；一般为1024     * @return密钥对儿（包含公钥和私钥）     */    public static KeyPair generateRSAKeyPair(int keyLength) {        try {            KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);            kpg.initialize(keyLength);            return kpg.genKeyPair();        } catch (NoSuchAlgorithmException e) {            e.printStackTrace();            return null;        }    }

生成了密钥对——一个公钥和一个私钥，两个密钥都可以进行加密和解密。这样我们就需要写四个方法，分别是：公钥加密、公钥解密、私密加密、私钥解密四个方法。

具体加密实现如下：

三、正常的加密、解密实现

1.公钥加密

        /**     * 使用公钥加密     *     * @param data       待加密数据     * @param publicKey 公钥     * @return byte[] 加密数据     */    public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {        // 得到公钥        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);        KeyFactory kf = KeyFactory.getInstance(RSA);        PublicKey keyPublic = kf.generatePublic(keySpec);        // 加密数据        Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);        cp.init(Cipher.ENCRYPT_MODE, keyPublic);        return cp.doFinal(data);    }    

2.私钥加密

        /**     * 使用私钥加密     *     * @param data       待加密数据     * @param privateKey 私钥     * @return byte[] 加密数据     */    public static byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {        // 得到私钥        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);        KeyFactory kf = KeyFactory.getInstance(RSA);        PrivateKey keyPrivate = kf.generatePrivate(keySpec);        // 数据加密        Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);        cipher.init(Cipher.ENCRYPT_MODE, keyPrivate);        return cipher.doFinal(data);    }    

3.公钥解密

        /**     * 使用公钥解密     *     * @param data      待解密数据     * @param publicKey 公钥     * @return byte[] 解密数据     */    public static byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {        // 得到公钥        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);        KeyFactory kf = KeyFactory.getInstance(RSA);        PublicKey keyPublic = kf.generatePublic(keySpec);        // 数据解密        Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);        cipher.init(Cipher.DECRYPT_MODE, keyPublic);        return cipher.doFinal(data);    }    

4.私钥解密

        /**     * 使用私钥进行解密     *     * @param data      待解密数据     * @param privateKey 私钥     * @return byte[] 解密数据     */    public static byte[] decryptByPrivateKey(byte[] encrypted, byte[] privateKey) throws Exception {        // 得到私钥        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);        KeyFactory kf = KeyFactory.getInstance(RSA);        PrivateKey keyPrivate = kf.generatePrivate(keySpec);        // 解密数据        Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);        cp.init(Cipher.DECRYPT_MODE, keyPrivate);        byte[] arr = cp.doFinal(encrypted);        return arr;    }    

几个全局变量解说：

public static final String RSA = "RSA";// 非对称加密密钥算法    public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding";//加密填充方式    public static final int DEFAULT_KEY_SIZE = 2048;//秘钥默认长度    public static final byte[] DEFAULT_SPLIT = "#PART#".getBytes();    // 当要加密的内容超过bufferSize，则采用partSplit进行分块加密    public static final int DEFAULT_BUFFERSIZE = (DEFAULT_KEY_SIZE / 8) - 11;// 当前秘钥支持加密的最大字节数    public static RSAPublicKey publicKey; // 公钥    public static RSAPrivateKey privateKey; // 私钥

关于加密填充方式：之前以为上面这些操作就能实现rsa加解密，以为万事大吉了，呵呵，这事还没完，悲剧还是发生了，Android这边加密过的数据，服务器端死活解密不了，原来android系统的RSA实现是"RSA/None/NoPadding"，而标准JDK实现是"RSA/None/PKCS1Padding" ，这造成了在android机上加密后无法在服务器上解密的原因，所以在实现的时候这个一定要注意。

实现分段加密：搞定了填充方式之后又自信的认为万事大吉了，可是意外还是发生了，RSA非对称加密内容长度有限制，1024位key的最多只能加密127位数据，否则就会报错(javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes) ，　RSA 是常用的非对称加密算法。最近使用时却出现了“不正确的长度”的异常，研究发现是由于待加密的数据超长所致。RSA 算法规定：待加密的字节数不能超过密钥的长度值除以 8 再减去 11（即：KeySize / 8 - 11），而加密后得到密文的字节数，正好是密钥的长度值除以 8（即：KeySize / 8）。

四、分段加密解密实现

1.公钥分段加密

        /**     * 用公钥对字符串进行分段加密     *      * @param data待加密数据     * @param publicKey公钥     */    public static byte[] encryptByPublicKeyForSpilt(byte[] data, byte[] publicKey) throws Exception {        int dataLen = data.length;        // 如果数据的长度不超过密钥支持的最大值，就直接进行加密操作        if (dataLen <= DEFAULT_BUFFERSIZE) {            return encryptByPublicKey(data, publicKey);        }        // 否则进行分段加密，allBytes是分段加密后数据的载体        List<Byte> allBytes = new ArrayList<Byte>(2048);        int bufIndex = 0;        int subDataLoop = 0;        byte[] buf = new byte[DEFAULT_BUFFERSIZE];        for (int i = 0; i < dataLen; i++) {            buf[bufIndex] = data[i];            // 如果到最大长度了或是到数组结尾了，就添加一个分段标识            if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {                subDataLoop++;                // 除了第一段，之后每两段之间加一个分段标识                if (subDataLoop != 1) {                    for (byte b : DEFAULT_SPLIT) {                        allBytes.add(b);                    }                }                byte[] encryptBytes = encryptByPublicKey(buf, publicKey);                for (byte b : encryptBytes) {                    allBytes.add(b);                }                bufIndex = 0;                if (i == dataLen - 1) {                    buf = null;                } else {                    buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];                }            }        }        byte[] bytes = new byte[allBytes.size()];        {            int i = 0;            for (Byte b : allBytes) {                bytes[i++] = b.byteValue();            }        }        return bytes;    }    

2.私钥分段加密

        /**     * 用私钥对字符串进行分段加密     *     * @param data       要加密的原始数据     * @param privateKey 私钥     */    public static byte[] encryptByPrivateKeyForSpilt(byte[] data, byte[] privateKey) throws Exception {        int dataLen = data.length;        // 如果数据的长度不超过密钥支持的最大值，就直接进行加密操作        if (dataLen <= DEFAULT_BUFFERSIZE) {            return encryptByPrivateKey(data, privateKey);        }        // 否则进行分段加密，allBytes是分段加密后数据的载体        List<Byte> allBytes = new ArrayList<Byte>(2048);        int bufIndex = 0;        int subDataLoop = 0;        byte[] buf = new byte[DEFAULT_BUFFERSIZE];        for (int i = 0; i < dataLen; i++) {            buf[bufIndex] = data[i];            // 如果到最大长度了或是到数组结尾了，就添加一个分段标识            if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {                subDataLoop++;                // 除了第一段，之后每两段之间加一个分段标识                if (subDataLoop != 1) {                    for (byte b : DEFAULT_SPLIT) {                        allBytes.add(b);                    }                }                byte[] encryptBytes = encryptByPrivateKey(buf, privateKey);                for (byte b : encryptBytes) {                    allBytes.add(b);                }                bufIndex = 0;                if (i == dataLen - 1) {                    buf = null;                } else {                    buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];                }            }        }        byte[] bytes = new byte[allBytes.size()];        {            int i = 0;            for (Byte b : allBytes) {                bytes[i++] = b.byteValue();            }        }        return bytes;    }   

3.公钥分段解密

        /**     * 用公钥对字符串进行分段解密     *     * @param encrypted 待解密数据     * @param publicKey 公钥     */    public static byte[] decryptByPublicKeyForSpilt(byte[] encrypted, byte[] publicKey) throws Exception {        int splitLen = DEFAULT_SPLIT.length;        // 如果分块解密的标识的长度为0，就直接进行加密操作，换句话说：如果没有分块解密的标识，直接进行解密        if (splitLen <= 0) {            return decryptByPublicKey(encrypted, publicKey);        }        // 否则进行分块解密        int dataLen = encrypted.length;        // 解密后数据的载体        List<Byte> allBytes = new ArrayList<Byte>(1024);        int latestStartIndex = 0;        for (int i = 0; i < dataLen; i++) {            byte bt = encrypted[i];            boolean isMatchSplit = false;            if (i == dataLen - 1) {                // 到data的最后了，直接进行解密                byte[] part = new byte[dataLen - latestStartIndex];                System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);                byte[] decryptPart = decryptByPublicKey(part, publicKey);                for (byte b : decryptPart) {                    allBytes.add(b);                }                latestStartIndex = i + splitLen;                i = latestStartIndex - 1;            } else if (bt == DEFAULT_SPLIT[0]) {                // 如果找到以split[0]开头字节，就开始判断其是否为分组标识，如果是就将isMatchSplit改为true                if (splitLen > 1) {                    if (i + splitLen < dataLen) {                        // 没有超出data的范围                        for (int j = 1; j < splitLen; j++) {                            if (DEFAULT_SPLIT[j] != encrypted[i + j]) {                                break;                            }                            if (j == splitLen - 1) {                                // 验证到split的最后一位，都没有break，则表明已经确认是split段（即：是分组标识）                                isMatchSplit = true;                            }                        }                    }                } else {                    // split只有一位，则已经匹配了                    isMatchSplit = true;                }            }            // 如果isMatchSplit为true，则就进行分割数据串，然后解密后放入allBytes            if (isMatchSplit) {                byte[] part = new byte[i - latestStartIndex];                System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);                byte[] decryptPart = decryptByPublicKey(part, publicKey);                for (byte b : decryptPart) {                    allBytes.add(b);                }                latestStartIndex = i + splitLen;                i = latestStartIndex - 1;            }        }        // 返回解密后数据        byte[] bytes = new byte[allBytes.size()];        {            int i = 0;            for (Byte b : allBytes) {                bytes[i++] = b.byteValue();            }        }        return bytes;    } 

4.私钥分段解密

        /**     * 用私钥对字符串进行分段解密     *      * @param encrypted待解密的数据     * @param privateKey私钥     */    public static byte[] decryptByPrivateKeyForSpilt(byte[] encrypted, byte[] privateKey) throws Exception {        int splitLen = DEFAULT_SPLIT.length;        // 如果分块解密的标识的长度为0，就直接进行加密操作，换句话说：如果没有分块解密的标识，直接进行解密        if (splitLen <= 0) {            return decryptByPrivateKey(encrypted, privateKey);        }        // 否则进行分块解密        int dataLen = encrypted.length;        // 解密后数据的载体        List<Byte> allBytes = new ArrayList<Byte>(1024);        int latestStartIndex = 0;        for (int i = 0; i < dataLen; i++) {            byte bt = encrypted[i];            boolean isMatchSplit = false;            if (i == dataLen - 1) {            // 到data的最后了，直接进行解密                byte[] part = new byte[dataLen - latestStartIndex];                System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);                byte[] decryptPart = decryptByPrivateKey(part, privateKey);                for (byte b : decryptPart) {                    allBytes.add(b);                }                latestStartIndex = i + splitLen;                i = latestStartIndex - 1;            } else if (bt == DEFAULT_SPLIT[0]) {            // 如果找到以split[0]开头字节，就开始判断其是否为分组标识，如果是就将isMatchSplit改为true                if (splitLen > 1) {                    if (i + splitLen < dataLen) {                        // 没有超出data的范围                        for (int j = 1; j < splitLen; j++) {                            if (DEFAULT_SPLIT[j] != encrypted[i + j]) {                                break;                            }                            if (j == splitLen - 1) {                            // 验证到split的最后一位，都没有break，则表明已经确认是split段（即：是分组标识）                                isMatchSplit = true;                            }                        }                    }                } else {                    // split只有一位，则已经匹配了                    isMatchSplit = true;                }            }            // 如果isMatchSplit为true，则就进行分割数据串，然后解密后放入allBytes            if (isMatchSplit) {                byte[] part = new byte[i - latestStartIndex];                System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);                byte[] decryptPart = decryptByPrivateKey(part, privateKey);                for (byte b : decryptPart) {                    allBytes.add(b);                }                latestStartIndex = i + splitLen;                i = latestStartIndex - 1;            }        }        // 返回解密后数据        byte[] bytes = new byte[allBytes.size()];        {            int i = 0;            for (Byte b : allBytes) {                bytes[i++] = b.byteValue();            }        }        return bytes;    }}

5.加密、解密的图文注解

在这儿我需要挂图进行注释一下，主要是将其逻辑可视化，让看代码的人更省时间，可以更快、更清楚的理解分块儿加密、分块解密的原理。好了，直接上图：

关于分块加密图解（私钥分块加密和公钥分块加密的原理一样一样的）：

关于分块解密图解（私钥分块解密和公钥分块解密的原理一样一样的）：

这样总算把遇见的问题解决了，接下来我们就进行一番测试，通过效率，我们来看看到底是选用公钥加密——私密解密的方式好，还是选用私钥加密——公钥解密的方式好。

五、实例测试

第一步：准备100条对象数据（基本数据不具代表性，我们平时还是用的对象多）

public static String getData() {List<Person> personList=new ArrayList<>();        int testMaxCount=100;//测试的最大数据条数        //添加测试数据        for(int i=0;i<testMaxCount;i++){            Person person =new Person();            person.setAge(i);            person.setName("name->" + String.valueOf(i));            personList.add(person);        }        // 生成自己想要测试的数据        String jsonData = personList.toString();        System.out.println("MainActivity:加密前数据 ---->" + jsonData);        System.out.println("MainActivity:加密前数据长度 ---->"+jsonData.length());        return jsonData;}

第二步：生成秘钥对

public static void getkey() {// 随机生成RSA密钥对KeyPair keyPair=RSAUtils.generateRSAKeyPair(RSAUtils.DEFAULT_KEY_SIZE);        // 公钥        publicKey = (RSAPublicKey) keyPair.getPublic();        // 私钥        privateKey = (RSAPrivateKey) keyPair.getPrivate();}

第三步：分别使用公钥加密——私钥解密 和 私钥加密——公钥解密

    public static void main(String[] args) {// 生成待加密的数据源String rawData = getData();// 得到随机的密钥对儿getkey();// 记录加密/解密开始时的系统时间（单位：ms）long start= 0; // 记录加密/解密结束时的系统时间（单位：ms）long end = 0;// 加密后的数据串（String型）String encryStr = "";// 解密后数据串（String型）String decryStr = "";// 加密后的数据（byte[]型的）byte[] encryptBytes;// 解密后数据（byte[]型的）byte[] decryptBytes;/** * 对数据进行：公钥加密，私钥解密 */try {//公钥加密start = System.currentTimeMillis();encryptBytes = RSAUtils.encryptByPublicKeyForSpilt(rawData.getBytes(),publicKey.getEncoded());        end=System.currentTimeMillis();        System.out.println("公钥加密耗时 cost time---->"+(end-start));        encryStr=Base64.getEncoder().encodeToString(encryptBytes);        System.out.println("加密后数据串 --1-->"+encryStr);        System.out.println("加密后数据串长度 --1-->"+encryStr.length());        //私钥解密        start=System.currentTimeMillis();        decryptBytes= RSAUtils.decryptByPrivateKeyForSpilt(Base64.getDecoder().decode(encryStr), privateKey.getEncoded());        end=System.currentTimeMillis();        System.out.println("私钥解密耗时 cost time---->"+(end-start));        decryStr=new String(decryptBytes);        System.out.println("解密后数据串 --1-->"+decryStr);} catch (Exception e1) {// TODO Auto-generated catch blocke1.printStackTrace();}        /** * 对数据进行：公钥加密，私钥解密 */        try {        //私钥加密        start=System.currentTimeMillis();encryptBytes= RSAUtils.encryptByPrivateKeyForSpilt(rawData.getBytes(),privateKey.getEncoded());    end=System.currentTimeMillis();    System.out.println("私钥加密密耗时 cost time---->"+(end-start));    encryStr=Base64.getEncoder().encodeToString(encryptBytes);    System.out.println("加密后数据串 --2-->"+encryStr);    System.out.println("加密后数据串长度 --2-->"+encryStr.length());    //公钥解密    start=System.currentTimeMillis();    decryptBytes=  RSAUtils.decryptByPublicKeyForSpilt(Base64.getDecoder().decode(encryStr),publicKey.getEncoded());    end=System.currentTimeMillis();    System.out.println("公钥解密耗时 cost time---->"+(end-start));    decryStr=new String(decryptBytes);    System.out.println("解密后数据串 --2-->"+decryStr);        } catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}

六、输出结果

接下来我们来看几组数据进行比较一番：

比对一：

公钥加密耗时 cost time---->224私钥解密耗时 cost time---->111私钥加密耗时 cost time---->116公钥解密耗时 cost time---->5

对比发现：私钥的加解密都很耗时，所以可以根据不同的需求采用不能方案来进行加解密。个人觉得服务器要求解密效率高，客户端私钥加密，服务器公钥解密比较好一点

比对二：

加密前数据长度 ---->3180公钥加密后数据串长度 --1-->4536私钥解密后数据串长度 --1-->3180私钥加密后数据串长度 --2-->4536公钥解密后数据串长度 --2-->3180

加密后数据大小的变化：数据量差不多是加密前的1.5倍

本文参考：http://www.cnblogs.com/whoislcj/p/5470095.html 博主的，并进行了验证和整理添加了注释。该博主是用Android Studio开发的，我是用Eclipse验证的，就是公钥加密耗时这块儿没对上，其他都对上了。不过对比发现的规律不变。

谢谢大家的阅读，如果有什么建议和疑问的朋友，还是老规矩，请留言，我们一块儿交流互动！谢谢！