上篇文章分析了对称加密算法的实现。小伙伴们想了解的话可以翻看一下昨天的文章。下边我们一起说说非对称加密算法的实现过程以及demo演示

什么是非对称加密？

非对称加密算法需要两个密钥来进行加密和解密，这两个秘钥是公开密钥（public key，简称公钥）和私有密钥（private key，简称私钥）。公开密钥与私有密钥是一对的，①如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；②如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

简单画图画图描述一下公私钥的配对问题

如果所示，甲乙之间使用非对称加密的方式完成了重要信息的安全传输。

1、乙方生成一对密钥（公钥和私钥）并将公钥向其它方公开。

2、得到该公钥的甲方使用该密钥对机密信息进行加密后再发送给乙方。

3、乙方再用自己保存的另一把专用密钥（私钥）对加密后的信息进行解密。乙方只能用其专用密钥（私钥）解密由对应的公钥加密后的信息。

在传输过程中，即使攻击者截获了传输的密文，并得到了乙的公钥，也无法破解密文，因为只有乙的私钥才能解密密文。

同样，如果乙要回复加密信息给甲，那么需要甲先公布甲的公钥给乙用于加密，甲自己保存甲的私钥用于解密。

RSA出场啦

在这里分享的时使用最广泛的一种非对称加密算法-RSA。RSA算法实现过程。因为牵扯数学概念，计算。所以这里大致说明一下，主要还是看下边的demo

1、生成密钥对（公钥和私钥）随机找两个质数a和b（a和b越大越安全），并计算他们的乘积n比如 a = 5 ，b = 11。计算他们的乘积 n = 5 * 11 = 55 ，转化为二进为 110111，该加密算法即为 6 位。本例子中是为了计算方便，所以取的数比较小，实际算法是 1024 位 或 2048 位，位数越长，算法越难被破解。

2、计算n的欧拉函数m = φ(n)根据公式m = φ(55) = φ(5)φ(11) = (5-1)(11-1) = 40

3、随机选择一个整数e，条件是1<e<m，且e与m互质我们随机选择e=17

4、计算e对于φ(n)（即m）的模反元素d即找一个整数 d，使得 (e * d ) % m = 1。 等价于 e * d - 1 = y * m ( y 为整数） 找到 d ，实质就是对下面二元一次方程求解。 e * x - m * y = 1 。其中 e = 17，m = 40，17x - 40y = 1 这个方程可以用"扩展欧几里得算法"求解。具体求解过程略，算出一组整数解（x，y ）= （33，14），即 d=33。 到此密钥对生成完毕。不同的e生成不同的d，因此可以生成多个密钥对。

5、这里公钥为（n，e) = (55 , 17)，私钥为（n，d) = (55 ，33) ，仅（n，e) =(55 , 17)是公开的，其余数字均不公开。可以想像如果只有 n 和 e，如何推导出 d，目前只能靠暴力破解，位数越长，暴力破解的时间越长。

最后，给大家供上最真实的RSA在java中的demo：

注意：在使用BASE64的时候，千万不要用encodeBase64URLSafe，因为这里边有个大坑。要用encodeBase64。说一下这两个方法的具体区别。 一定要注意

区别在于encodeBase64会对字符串3位一组自动补全，因而最后可能会出现 == 或者 =，而encodeBase64URLSafe则是按照字符串实际位数进行加密，最后若为1位，则不补全，不会出现 == 或者 =

最重要的部分

package com.jd.rsa;

import org.bouncycastle.util.encoders.Base64;
import sun.misc.IOUtils;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * @program: yuanjinsong-java-encryption
 * @author: 袁劲松
 * @create: 2020-03-28 15:23
 * @description: 功能描述（）
 **/
public class RsaUtil {

    private static final String CHARSET = "UTF-8";
    //java默认"RSA"="RSA/ECB/PKCS1Padding"
    // 算法/模式/补码方式
    private static final String RSA_ALGORITHM = "RSA";

    /**
     * 生成公私钥的方法
     *
     * @param keySize 公私钥的长度
     * @return
     */
    public static Map<String, String> createKeys(int keySize) {
        // 为RSA算法创建一个KeyPairGenerator对象
        KeyPairGenerator kpg;
        try {
            kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
        }

        // 初始化KeyPairGenerator对象,密钥长度
        kpg.initialize(keySize);
        // 生成密匙对
        KeyPair keyPair = kpg.generateKeyPair();
        // 得到公钥
        Key publicKey = keyPair.getPublic();
        String publicKeyStr = new String(Base64.encode(publicKey.getEncoded()));
        // 得到私钥
        Key privateKey = keyPair.getPrivate();
        String privateKeyStr = new String(Base64.encode(privateKey.getEncoded()));
        // map装载公钥和私钥
        Map<String, String> keyPairMap = new HashMap<>();
        keyPairMap.put("publicKey", publicKeyStr);
        keyPairMap.put("privateKey", privateKeyStr);
        // 返回map
        return keyPairMap;
    }

    /**
     * 获取公钥
     *
     * @param publicKey  密钥字符串（经过base64编码）
     *
     */
    public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        // 通过X509编码的Key指令获得公钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decode(publicKey));
        RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
        return key;
    }

    /**
     * 获取私钥
     *
     * @param privateKey  密钥字符串（经过base64编码）
     *
     */
    public static RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        // 通过PKCS#8编码的Key指令获得私钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
        RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
        return key;
    }

    /**
     * 公钥加密明文
     *
     * @param data       明文
     * @param publicKey  公钥
     * @return           密文
     */
    public static String publicEncrypt(String data, RSAPublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            return new String(Base64.encode(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength())));
        } catch (Exception e) {
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 私钥解密密文
     *
     * @param data       密文
     * @param privateKey 私钥
     * @return           明文
     */

    public static String privateDecrypt(String data, RSAPrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decode(data), privateKey.getModulus().bitLength()), CHARSET);
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 私钥加密明文
     *
     * @param data       明文
     * @param privateKey 秘钥
     * @return           密文
     */

    public static String privateEncrypt(String data, RSAPrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            //每个Cipher初始化方法使用一个模式参数opmod，并用此模式初始化Cipher对象。此外还有其他参数，包括密钥key、包含密钥的证书certificate、算法参数params和随机源random。
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            return new String(Base64.encode(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), privateKey.getModulus().bitLength())));
        } catch (Exception e) {
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 公钥解密密文
     *
     * @param data       密文
     * @param publicKey  公钥
     * @return           明文
     */
    public static String publicDecrypt(String data, RSAPublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decode(data), publicKey.getModulus().bitLength()), CHARSET);
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * rsa切割解码  , ENCRYPT_MODE,加密数据   ,DECRYPT_MODE,解密数据
     *
     * @param cipher    //java默认"RSA"="RSA/ECB/PKCS1Padding"
     * @param opmode    ENCRYPT_MODE,加密数据   ,DECRYPT_MODE,解密数据
     * @param datas     明文/密文
     * @param keySize   长短
     * @return          加密/解密 后的数据
     * @throws IOException
     */
    private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) throws IOException {
        int maxBlock = 0;  //最大块
        if (opmode == Cipher.DECRYPT_MODE) {
            maxBlock = keySize / 8;
        } else {
            maxBlock = keySize / 8 - 11;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] buff;
        int i = 0;
        try {
            while (datas.length > offSet) {
                if (datas.length - offSet > maxBlock) {
                    //可以调用以下的doFinal（）方法完成加密或解密数据：
                    buff = cipher.doFinal(datas, offSet, maxBlock);
                } else {
                    buff = cipher.doFinal(datas, offSet, datas.length - offSet);
                }
                out.write(buff, 0, buff.length);
                i++;
                offSet = i * maxBlock;
            }
        } catch (Exception e) {
            throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
        }
        byte[] resultDatas = out.toByteArray();
        out.close();
        return resultDatas;
    }



    public static void main(String[] args) throws Exception {
        Map<String, String> keyMap = RsaUtil.createKeys(1024);
        String publicKey = keyMap.get("publicKey");
        String privateKey = keyMap.get("privateKey");
        System.out.println("公钥: \n\r" + publicKey);
        System.out.println("私钥： \n\r" + privateKey);

        System.out.println("公钥加密——私钥解密");
        String str = "jinsong";
        System.out.println("\r明文：\r\n" + str);
        System.out.println("\r明文大小：\r\n" + str.getBytes().length);
        //传入明文和公钥加密,得到密文
        String encodedData = RsaUtil.publicEncrypt(str, RsaUtil.getPublicKey(publicKey));
        System.out.println("密文：\r\n" + encodedData);
        //传入密文和私钥,得到明文
        String decodedData = RsaUtil.privateDecrypt(encodedData, RsaUtil.getPrivateKey(privateKey));
        System.out.println("解密后文字: \r\n" + decodedData);

    }
}

大家好，我是小劲，专注分享java知识点，如有总结不到位的，欢迎小伙伴指点。感谢大家阅读，欢迎点赞、转发...

大家有什么建议或者补充的可以在下方留言，咱们一起讨论