Java 中 RSA 工具类

Java 中使用 RSA 的工具类

RSAUtil

import org.springframework.core.io.ClassPathResource;
import org.springframework.util.ResourceUtils;

import javax.crypto.Cipher;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author wwh
 * @date 2019/11/7 17:40
 * @description
 */
public class RSAUtil {

    public static final String ALGORITHM = "RSA";

    /**
     * 生成的公钥文件名称
     */
    public static final String PUBLIC_KEY_NAME = "public.key";

    /**
     * 生成的私钥文件名称
     */
    public static final String PRIVATE_KEY_NAME = "private.key";

    /**
     * Key文件存放目录
     */
    public static final String KEY_PATH = "key";

    /**
     * 指定生成多少位的密钥
     */
    private static final int KEY_BIT = 2048;

    /**
     * RSA最大加密明文大小
     * 1024位的密钥要改成117,2048位的是245
     */
    private static final int MAX_ENCRYPT_BLOCK = 245;

    /**
     * RSA最大解密密文大小
     * 1024位的密钥要改成128,2048位的是256
     */
    private static final int MAX_DECRYPT_BLOCK = 256;

    private static final Map<String, String> KEY_MAP = new ConcurrentHashMap<>(2);

    /**
     * 签名算法
     */
    // public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    // public static final String SIGNATURE_ALGORITHM = "SHA1withRSA";
    public static final String SIGNATURE_ALGORITHM = "SHA256withRSA";

    /**
     * 生成密钥对：密钥对中包含公钥和私钥
     *
     * @return 包含 RSA 公钥与私钥的 keyPair
     * @throws NoSuchAlgorithmException NoSuchAlgorithmException
     */
    public static KeyPair generateKeyPair() throws NoSuchAlgorithmException {
        // 获得RSA密钥对的生成器实例
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        // 获得一个安全的随机数
        SecureRandom secureRandom = new SecureRandom(String.valueOf(System.currentTimeMillis()).getBytes(StandardCharsets.UTF_8));
        // 这里可以是1024、2048 初始化一个密钥对
        keyPairGenerator.initialize(KEY_BIT, secureRandom);
        // 获得密钥对
        return keyPairGenerator.generateKeyPair();
    }

    /**
     * 生成密钥对写入到文件
     *
     * @throws NoSuchAlgorithmException NoSuchAlgorithmException
     */
    public static void generateKeyPair(String privateKeyName, String publicKeyName, String keyPath) throws NoSuchAlgorithmException, IOException {
        KeyPair keyPair = generateKeyPair();
        String privateKey = getPrivateKey(keyPair);
        writeFile(keyPath + File.separator + privateKeyName, privateKey.getBytes(StandardCharsets.UTF_8));
        String publicKey = getPublicKey(keyPair);
        writeFile(keyPath + File.separator + publicKeyName, publicKey.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * 写入key到文件
     *
     * @param fileName key文件名称
     * @param data     key内容
     * @throws IOException IOException
     */
    private static void writeFile(String fileName, byte[] data) throws IOException {
        if (Files.notExists(Paths.get(fileName))) {
            Files.createFile(Paths.get(fileName));
        }
        try (RandomAccessFile rw = new RandomAccessFile(fileName, "rw")) {
            rw.write(data, 0, data.length);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取公钥 (并进行 Base64 编码，返回一个 Base64 编码后的字符串)
     *
     * @param keyPair：RSA 密钥对
     * @return 返回一个 Base64 编码后的公钥字符串
     */
    public static String getPublicKey(KeyPair keyPair) {
        PublicKey publicKey = keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return Base64.getEncoder().encodeToString(bytes);
    }

    /**
     * 从文件中读取公钥
     *
     * @param publicKeyName 公钥文件名称
     * @return 公钥 BASE64编码
     */
    public static String getPublicKey(String publicKeyName) {
        return KEY_MAP.computeIfAbsent(PUBLIC_KEY_NAME, key -> readFile(publicKeyName));
    }

    /**
     * 从文件中读取私钥
     *
     * @param privateKeyName 私钥文件名称
     * @return 私钥 BASE64编码
     */
    public static String getPrivateKey(String privateKeyName) {
        return KEY_MAP.computeIfAbsent(PRIVATE_KEY_NAME, key -> readFile(privateKeyName));
    }

    /**
     * 写入key文件
     *
     * @param keyName key文件名称
     * @return key
     */
    private static String readFile(String keyName) {
        try (InputStream inputStream = new ClassPathResource(KEY_PATH + File.separator + keyName).getInputStream();
             ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, len);
            }
            return outputStream.toString(StandardCharsets.UTF_8.name());
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(0);
        }
        return null;
    }

    /**
     * 获取私钥(并进行Base64编码，返回一个 Base64 编码后的字符串)
     *
     * @param keyPair：RSA 密钥对
     * @return 返回一个 Base64 编码后的私钥字符串
     */
    public static String getPrivateKey(KeyPair keyPair) {
        PrivateKey privateKey = keyPair.getPrivate();
        byte[] bytes = privateKey.getEncoded();
        return Base64.getEncoder().encodeToString(bytes);
    }

    /**
     * 将 Base64 编码后的公钥转换成 PublicKey 对象
     *
     * @param publicKey：Base64 编码后的公钥字符串
     * @return PublicKey publicKey
     */
    public static PublicKey string2PublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] bytes = Base64.getDecoder().decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePublic(keySpec);
    }

    /**
     * 将 Base64 码后的私钥转换成 PrivateKey 对象
     *
     * @param privateKey Base64 编码后的私钥字符串
     * @return PrivateKey privateKey
     */
    public static PrivateKey string2PrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] bytes = Base64.getDecoder().decode(privateKey);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePrivate(keySpec);
    }

    /**
     * 使用私钥分段加密
     *
     * @param data       要加密的数据
     * @param privateKey 私钥
     * @return 加密后的数据 BASE64编码
     */
    public static byte[] encrypt(byte[] data, PrivateKey privateKey) throws GeneralSecurityException, IOException {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        return Base64.getEncoder().encode(segment(data, cipher, MAX_ENCRYPT_BLOCK));
    }

    /**
     * 使用私钥分段加密
     *
     * @param data       要加密的数据
     * @param privateKey 私钥
     * @return 加密后的数据 BASE64编码
     */
    public static String encrypt(String data, PrivateKey privateKey) throws GeneralSecurityException, IOException {
        byte[] encrypt = encrypt(data.getBytes(StandardCharsets.UTF_8), privateKey);
        return new String(encrypt);
    }

    /**
     * 使用公钥分段加密
     *
     * @param data      要加密的数据
     * @param publicKey 公钥
     * @return 加密后的数据
     */
    public static byte[] encrypt(byte[] data, PublicKey publicKey) throws GeneralSecurityException, IOException {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return Base64.getEncoder().encode(segment(data, cipher, MAX_ENCRYPT_BLOCK));
    }

    /**
     * 使用公钥分段加密
     *
     * @param data      要加密的数据
     * @param publicKey 公钥
     * @return 加密后的数据 BASE64编码
     */
    public static String encrypt(String data, PublicKey publicKey) throws GeneralSecurityException, IOException {
        byte[] encrypt = encrypt(data.getBytes(StandardCharsets.UTF_8), publicKey);
        return new String(encrypt);
    }

    /**
     * 使用公钥/私钥分段加密
     *
     * @param data      要加密的数据
     * @param secretKey 秘钥
     * @param keyType   秘钥类型
     * @return 加密后的数据 BASE64编码
     */
    public static String encrypt(String data, String secretKey, KeyType keyType) throws GeneralSecurityException, IOException {
        byte[] encrypt;
        if (Objects.equals(KeyType.PRIVATE_KEY, keyType)) {
            encrypt = encrypt(data.getBytes(StandardCharsets.UTF_8), string2PrivateKey(secretKey));
            return new String(encrypt);
        }
        if (Objects.equals(KeyType.PUBLIC_KEY, keyType)) {
            encrypt = encrypt(data.getBytes(StandardCharsets.UTF_8), string2PrivateKey(secretKey));
            return new String(encrypt);
        }
        return null;
    }

    /**
     * 使用私钥分段解密
     *
     * @param data       要解密的数据
     * @param privateKey 私钥
     * @return 解密后的数据
     */
    public static byte[] decrypt(byte[] data, PrivateKey privateKey) throws GeneralSecurityException, IOException {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return segment(Base64.getDecoder().decode(data), cipher, MAX_DECRYPT_BLOCK);
    }

    /**
     * 使用私钥分段解密
     *
     * @param data       要解密的数据 BASE64编码
     * @param privateKey 私钥
     * @return 解密后的数据
     */
    public static String decrypt(String data, PrivateKey privateKey) throws GeneralSecurityException, IOException {
        byte[] encrypt = decrypt(data.getBytes(StandardCharsets.UTF_8), privateKey);
        return new String(encrypt);
    }

    /**
     * 使用公钥分段解密
     *
     * @param data      要解密的数据
     * @param publicKey 公钥
     * @return 解密后的数据
     */
    public static byte[] decrypt(byte[] data, PublicKey publicKey) throws GeneralSecurityException, IOException {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        return segment(Base64.getDecoder().decode(data), cipher, MAX_DECRYPT_BLOCK);
    }

    /**
     * 使用公钥分段解密
     *
     * @param data      要解密的数据 BASE64编码
     * @param publicKey 公钥
     * @return 解密后的数据
     */
    public static String decrypt(String data, PublicKey publicKey) throws GeneralSecurityException, IOException {
        byte[] encrypt = decrypt(data.getBytes(StandardCharsets.UTF_8), publicKey);
        return new String(encrypt);
    }

    /**
     * 使用公钥/私钥分段解密
     *
     * @param data      要解密的数据 BASE64编码
     * @param secretKey 秘钥
     * @param keyType   秘钥类型
     * @return 解密后的数据
     */
    public static String decrypt(String data, String secretKey, KeyType keyType) throws GeneralSecurityException, IOException {
        byte[] encrypt;
        if (Objects.equals(KeyType.PUBLIC_KEY, keyType)) {
            encrypt = decrypt(data.getBytes(StandardCharsets.UTF_8), string2PublicKey(secretKey));
            return new String(encrypt);
        }
        if (Objects.equals(KeyType.PRIVATE_KEY, keyType)) {
            encrypt = decrypt(data.getBytes(StandardCharsets.UTF_8), string2PrivateKey(secretKey));
            return new String(encrypt);
        }
        return null;
    }

    /**
     * 分段进行加密/解密
     *
     * @param data     要加密/解密的数据
     * @param cipher   cipher 实例
     * @param maxBlock 分段加密块的大小
     * @return 加密/解密后的数据
     * @throws GeneralSecurityException GeneralSecurityException
     * @throws IOException              IOException
     */
    private static byte[] segment(byte[] data, Cipher cipher, int maxBlock) throws GeneralSecurityException, IOException {
        int dataLength = data.length;
        int offset = 0;
        byte[] cache;
        int i = 0;
        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            // 数据分段加密
            while (dataLength - offset > 0) {
                if (dataLength - offset > maxBlock) {
                    cache = cipher.doFinal(data, offset, maxBlock);
                } else {
                    cache = cipher.doFinal(data, offset, dataLength - offset);
                }
                out.write(cache, 0, cache.length);
                ++i;
                offset = i * maxBlock;
            }
            return out.toByteArray();
        }
    }

    /**
     * 签名
     *
     * @param data       要签名的数据
     * @param privateKey 私钥
     * @return 签名 BASE编码
     * @throws GeneralSecurityException GeneralSecurityException
     */
    public static byte[] sign(byte[] data, PrivateKey privateKey) throws GeneralSecurityException {
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateKey);
        signature.update(data);
        return Base64.getEncoder().encode(signature.sign());
    }

    /**
     * 签名
     *
     * @param data       要签名的数据
     * @param privateKey 私钥
     * @return 签名 BASE编码
     * @throws GeneralSecurityException GeneralSecurityException
     */
    public static String sign(String data, PrivateKey privateKey) throws GeneralSecurityException {
        byte[] sign = sign(data.getBytes(StandardCharsets.UTF_8), privateKey);
        return new String(sign);
    }

    /**
     * 签名
     *
     * @param data       要签名的数据
     * @param privateKey 私钥
     * @return 签名 BASE编码
     * @throws GeneralSecurityException GeneralSecurityException
     */
    public static String sign(String data, String privateKey) throws GeneralSecurityException {
        if (Objects.isNull(data) || Objects.isNull(privateKey)) {
            return null;
        }
        byte[] sign = sign(data.getBytes(StandardCharsets.UTF_8), string2PrivateKey(privateKey));
        return new String(sign);
    }

    /**
     * 验签
     *
     * @param data      私钥加密后的数据 BASE64编码
     * @param sign      私钥签名 BASE64编码
     * @param publicKey 公钥
     * @return true-合法签名 false-非法签名
     */
    public static boolean verify(byte[] data, String sign, PublicKey publicKey) throws GeneralSecurityException {
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicKey);
        signature.update(data);
        return signature.verify(Base64.getDecoder().decode(sign));
    }

    /**
     * 验签
     *
     * @param data      私钥加密后的数据 BASE64编码
     * @param sign      私钥签名 BASE64编码
     * @param publicKey 公钥
     * @return true-合法签名 false-非法签名
     */
    public static boolean verify(String data, String sign, PublicKey publicKey) throws GeneralSecurityException {
        return verify(data.getBytes(StandardCharsets.UTF_8), sign, publicKey);
    }

    /**
     * 验签
     *
     * @param data      私钥加密后的数据 BASE64编码
     * @param sign      私钥签名 BASE64编码
     * @param publicKey 公钥
     * @return true-合法签名 false-非法签名
     */
    public static boolean verify(String data, String sign, String publicKey) throws GeneralSecurityException {
        if (Objects.isNull(data) || Objects.isNull(sign) || Objects.isNull(publicKey)) {
            return false;
        }
        return verify(data.getBytes(StandardCharsets.UTF_8), sign, string2PublicKey(publicKey));
    }

    /**
     * key类型
     */
    public enum KeyType {
        /**
         * 公钥
         */
        PUBLIC_KEY,

        /**
         * 私钥
         */
        PRIVATE_KEY
    }

    public static void main(String[] args) throws NoSuchAlgorithmException, IOException {

        // 在项目根目录生成key
        File path = ResourceUtils.getFile(KEY_PATH);
        if (!path.exists()) {
            boolean mkdir = path.mkdir();
        }
        generateKeyPair(PUBLIC_KEY_NAME, PRIVATE_KEY_NAME, KEY_PATH);
    }
}