RSA 加解密

package com.ruoyi.common.utils;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

/**
 * RSA 加解密工具类
 *
 * @Author: lizixian
 * @date: 2022/3/26 13:32
 */
public class RSAEncryptV2Util {

    // 加密算法RSA
    public static final String KEY_ALGORITHM = "RSA";

    // RSA最大加密明文大小
    private static final int MAX_ENCRYPT_BLOCK = 117;

    // RSA最大解密密文大小
    private static final int MAX_DECRYPT_BLOCK = 128;

    // 生成密钥对(公钥和私钥)
    public static void genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        // Base64 编码公私钥（Base64编码是从二进制到字符的过程）
        String publicKeyStr = Base64.getEncoder().encodeToString(publicKey.getEncoded());
        String privateKeyStr = Base64.getEncoder().encodeToString(privateKey.getEncoded());
        System.out.println("公钥：" + publicKeyStr);
        System.out.println("私钥：" + privateKeyStr);
    }

    /**
     * 私钥解密
     *
     * @param encData    已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return 明文（utf-8编码）
     * @Author: lizixian
     * @date: 2022/3/26 13:28
     */
    public static String decryptByPrivateKey(String encData, String privateKey) throws Exception {
        byte[] encDataBytes = Base64.getDecoder().decode(encData);
        byte[] keyBytes = Base64.getDecoder().decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encDataBytes.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encDataBytes, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encDataBytes, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return new String(decryptedData, "UTF-8");
    }

    /**
     * 公钥解密
     *
     * @param encData   已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @return 明文（utf-8编码）
     * @Author: lizixian
     * @date: 2022/3/26 13:30
     */
    public static String decryptByPublicKey(String encData, String publicKey) throws Exception {
        byte[] encDataBytes = Base64.getDecoder().decode(encData);
        byte[] keyBytes = Base64.getDecoder().decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encDataBytes.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encDataBytes, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encDataBytes, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return new String(decryptedData, "UTF-8");
    }

    /**
     * 公钥加密
     *
     * @param data      源数据
     * @param publicKey 公钥(BASE64编码)
     * @return 已加密数据
     * @Author: lizixian
     * @date: 2022/3/26 13:33
     */
    public static String encryptByPublicKey(String data, String publicKey) throws Exception {
        byte[] dataBytes = data.getBytes("UTF-8");
        byte[] keyBytes = Base64.getDecoder().decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = dataBytes.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(dataBytes, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(dataBytes, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return Base64.getEncoder().encodeToString(encryptedData);
    }

    /**
     * 私钥加密
     *
     * @param data       源数据
     * @param privateKey 私钥(BASE64编码)
     * @Author: lizixian
     * @date: 2022/3/26 13:34
     */
    public static String encryptByPrivateKey(String data, String privateKey) throws Exception {
        byte[] dataBytes = data.getBytes("UTF-8");
        byte[] keyBytes = Base64.getDecoder().decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = dataBytes.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;

        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(dataBytes, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(dataBytes, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return Base64.getEncoder().encodeToString(encryptedData);
    }

    private static final String PUBLIC_KEY_01 = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCG6FZnQ+nWjxl5usKkj0yAlLNz3VvGYcrfYI5M0ivGmQT+/7rWlsdPbZ5kl04cMsKnLT817z85Wg662idXtijoyev+arKZNW5Q2/GFqy8gyX5MkKHtkp+RIg+8TpltJnUk/LSulzkGhFxWGpJGkrovX7DFnLZY1m0BOUI3akC/EQIDAQAB";
    private static final String PRIVATE_KEY_01 = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIboVmdD6daPGXm6wqSPTICUs3PdW8Zhyt9gjkzSK8aZBP7/utaWx09tnmSXThwywqctPzXvPzlaDrraJ1e2KOjJ6/5qspk1blDb8YWrLyDJfkyQoe2Sn5EiD7xOmW0mdST8tK6XOQaEXFYakkaSui9fsMWctljWbQE5QjdqQL8RAgMBAAECgYAbpL4XuOXQjlAFDozV1XsymcXPxxsIIn/El+9wtFw9/Jr2eYZadFjw4KBlMk/SHWCfivj530VQRjDgftUy9uOYy4rFbrRG1yIX6I+JCoWJuHJUriocrw5OYUXUxSzpZLpXWgfTvGjkYTOoijfDBcRQUahhyHM18RoAwOPAAuNMAQJBAMP4Z+xLs3HLgaBAFHV3O7xNwAJ5Et1cbJGfp8EvDn1Fi9qvFrp+WE/HdVDA35K0AAMEWb23dVKy5byU3fcZNFECQQCwO4OODvLQj+XjCmr5nroGsCfkXhALMxBxBIF14OTfceYG31Z4ij6vCv+sUkjBeKhzvud/0ChFB3Mah7ORje7BAkA06wIdE8AMDXkebc9YfO77hT9BK7KFZezHUgZ5qxxNhZcjYT5Q88cjG+g4+ywkMEkEh4s4KK8cusRArS5XCE5RAkEAr81eyfrtjNLPsHK3Dnah+oQF95FCDfoNv8CP6OjFSIXVwytOlobKS1H8hYm8HIxh9r0NMPqVAW+SCngu0Ne2wQJAEpsAEGDmTXDrTWQlHSttuh2AghaEQgFfKWPnObTpdWRJcRcqLXRZfLypVNDEAniwaP8JB4vr/q6hM03qMsU42Q==";

    public static void main(String[] args) throws Exception {
        String content = "我爱中国 hello word v";

        String encode = encryptByPublicKey(content, PUBLIC_KEY_01);
        System.out.println("加密后的数据是:" + encode);

        content = decryptByPrivateKey(encode, PRIVATE_KEY_01);
        System.out.println("加密后的数据是:" + content);

        // 生成公私钥
//        genKeyPair();
    }
}