Java 非对称加密RSA应用实现

1.RSA介绍

RSA算法是一种非对称加密算法，与对称加密算法不同的是,RSA算法有两个不同的密钥，一个是公钥，一个是私钥。

RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥，“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制 。在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，而解密密钥（即私有密钥）SK是需要保密的。加密算法E和解密算法D也都是公开的。虽然解密密钥SK是由公开密钥PK决定的，但却不能根据PK计算出SK 。

2.算法描述

RSA算法的具体描述如下：

（1）任意选取两个不同的大素数p和q计算乘积：

（2）任意选取一个大整数e，满足 ，整数e用做加密钥（注意：e的选取是很容易的，例如，所有大于p和q的素数都可用）；

（3）确定的解密钥d，满足 ，即 是一个任意的整数；所以，若知道e和，则很容易计算出d ；

（4）公开整数n和e，秘密保存d；

（5）将明文m（m<n是一个整数）加密成密文c，加密算法为：

（6）将密文c解密为明文m，解密算法为：

然而只根据n和e（注意：不是p和q）要计算出d是不可能的。因此，任何人都可对明文进行加密，但只有授权用户（知道d）才可对密文解密。

3.应用示例

因为RSA加解密的算法性能比较低，可以使用AES加密文件，然后RSA只用来对AES秘钥进行加解密，这样以来可以更加高效、安全的实现文件的加解密传输。AES实现可以参考：Java 对称加密AES、DES的实现

4.RSA实现Java代码

package com.gnss.common.utils;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;

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.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * 非对称加密RAS
 * @author Mr.Li
 * @date 2024-04-20
 */
@Slf4j
public class RsaUtils {
    private static final String PUB_KEY = "publicKey";
    private static final String PRI_KEY = "privateKey";
    private static final String CHARSET = "UTF-8";
    private static final String RSA_ALGORITHM = "RSA";
    private static final Integer KEY_LENGTH = 1024;
    public static final Map<String, String> keyMap = createKeys(KEY_LENGTH);

    /**
     * 生成秘钥对
     *
     * @param keySize 秘钥长度
     * @return Map<String,String>
     */
    private static Map<String, String> createKeys(int keySize) {
        KeyPairGenerator kpg;
        try {
            kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
            log.error("No such algorithm-->[{}]",RSA_ALGORITHM,e);
            return null;
        }
        //初始化KeyPairGenerator对象,密钥长度
        kpg.initialize(keySize);
        //生成密匙对
        KeyPair keyPair = kpg.generateKeyPair();
        //得到公钥
        Key publicKey = keyPair.getPublic();
        String publicKeyStr = new String(Base64.encodeBase64(publicKey.getEncoded()));
        //得到私钥
        Key privateKey = keyPair.getPrivate();
        String privateKeyStr = new String(Base64.encodeBase64(privateKey.getEncoded()));
        Map<String, String> keyPairMap = new HashMap<>(1);
        keyPairMap.put(PUB_KEY, publicKeyStr);
        keyPairMap.put(PRI_KEY, privateKeyStr);
        return keyPairMap;
    }

    /**
     * 得到公钥
     *
     * @throws Exception
     */
    public static String getPublicKey()  {
        return keyMap.get(PUB_KEY);
    }

    /**
     * 得到私钥
     *
     * @throws Exception
     */
    public static String getPrivateKey()  {
        return keyMap.get(PRI_KEY);
    }

    /**
     * 公钥加密
     *
     * @param data
     * @param publicKey
     * @return
     */
    public static String publicEncrypt(String data, String publicKey) {
        try {
            //通过X509编码的Key指令获得公钥对象
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
            RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            return new String(Base64.encodeBase64(rsaCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), key.getModulus().bitLength())));
        } catch (Exception e) {
            log.error("加密字符串[{}]时遇到异常",data,e);
            return null;
        }
    }

    /**
     * 私钥解密
     *
     * @param data
     * @param privateKey
     * @return
     */
    public static String privateDecrypt(String data, String privateKey) {
        try {
            //通过PKCS#8编码的Key指令获得私钥对象
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
            RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, key);
            return new String(rsaCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), key.getModulus().bitLength()), CHARSET);
        } catch (Exception e) {
            log.error("解密字符串[{}]时遇到异常",data);
            return null;
        }
    }

    /**
     * RSA加解密
     * @param cipher
     * @param opMode
     * @param dataBytes
     * @param keySize
     * @return
     * @throws IOException
     * @throws IOException
     */
    private static byte[] rsaCodec(Cipher cipher, int opMode, byte[] dataBytes, int keySize) throws IOException, 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 (dataBytes.length > offSet) {
                if (dataBytes.length - offSet > maxBlock) {
                    buff = cipher.doFinal(dataBytes, offSet, maxBlock);
                } else {
                    buff = cipher.doFinal(dataBytes, offSet, dataBytes.length - offSet);
                }
                out.write(buff, 0, buff.length);
                i++;
                offSet = i * maxBlock;
            }
        } catch (Exception e) {
            log.error("加解密阀值为[{}]的数据时发生异常",maxBlock,e);
        }
        byte[] resultDataBytes = out.toByteArray();
        out.close();
        return resultDataBytes;
    }
}