Rsa 加解密

/**
 * RSA公钥加密
 *
 * @param str       加密字符串
 * @param publicKey 公钥
 * @return 密文
 * @throws Exception 加密过程中的异常信息
 */
public static String publicKeyEncrypt(String str, String publicKey, String point) throws Exception {
    log.info("{}|RSA公钥加密前的数据|str:{}|publicKey:{}", point, str, publicKey);
    //base64编码的公钥
    byte[] decoded = Base64.decodeBase64(publicKey);
    RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").
            generatePublic(new X509EncodedKeySpec(decoded));
    //RSA加密
    Cipher cipher = Cipher.getInstance("RSA");
    cipher.init(Cipher.ENCRYPT_MODE, pubKey);

    //当长度过长的时候，需要分割后加密 117个字节
    byte[] resultBytes = getMaxResultEncrypt(str, point, cipher);

    String outStr = Base64.encodeBase64String(resultBytes);
    log.info("{}|公钥加密后的数据|outStr:{}", point, outStr);
    return outStr;
}

private static byte[] getMaxResultEncrypt(String str, String point, Cipher cipher) throws IllegalBlockSizeException, BadPaddingException {
    byte[] inputArray = str.getBytes();
    int inputLength = inputArray.length;
    log.info("{}|加密字节数|inputLength:{}", point, inputLength);
    // 最大加密字节数，超出最大字节数需要分组加密
    int MAX_ENCRYPT_BLOCK = 117;
    // 标识
    int offSet = 0;
    byte[] resultBytes = {};
    byte[] cache = {};
    while (inputLength - offSet > 0) {
        if (inputLength - offSet > MAX_ENCRYPT_BLOCK) {
            cache = cipher.doFinal(inputArray, offSet, MAX_ENCRYPT_BLOCK);
            offSet += MAX_ENCRYPT_BLOCK;
        } else {
            cache = cipher.doFinal(inputArray, offSet, inputLength - offSet);
            offSet = inputLength;
        }
        resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
        System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
    }
    return resultBytes;
}

/**
 * RSA私钥解密
 *
 * @param str        加密字符串
 * @param privateKey 私钥
 * @param point
 * @return 铭文
 * @throws Exception 解密过程中的异常信息
 */
public static String privateKeyDecrypt(String str, String privateKey, String point) throws Exception {
    log.info("{}|RSA私钥解密前的数据|str:{}|privateKey:{}", point, str, privateKey);
    //64位解码加密后的字符串
    byte[] inputByte = Base64.decodeBase64(str.getBytes("UTF-8"));
    //base64编码的私钥
    byte[] decoded = Base64.decodeBase64(privateKey);
    RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA")
            .generatePrivate(new PKCS8EncodedKeySpec(decoded));
    //RSA解密
    Cipher cipher = Cipher.getInstance("RSA");
    cipher.init(Cipher.DECRYPT_MODE, priKey);

// String outStr = new String(cipher.doFinal(inputByte));
//当长度过长的时候，需要分割后解密 128个字节
String outStr = new String(getMaxResultDecrypt(str, point, cipher));
log.info("{}|RSA私钥解密后的数据|outStr:{}", point, outStr);
return outStr;
}

private static byte[] getMaxResultDecrypt(String str, String point, Cipher cipher) throws IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
    byte[] inputArray = Base64.decodeBase64(str.getBytes("UTF-8"));
    int inputLength = inputArray.length;
    log.info("{}|解密字节数|inputLength:{}", point, inputLength);
    // 最大解密字节数，超出最大字节数需要分组加密
    int MAX_ENCRYPT_BLOCK = 128;
    // 标识
    int offSet = 0;
    byte[] resultBytes = {};
    byte[] cache = {};
    while (inputLength - offSet > 0) {
        if (inputLength - offSet > MAX_ENCRYPT_BLOCK) {
            cache = cipher.doFinal(inputArray, offSet, MAX_ENCRYPT_BLOCK);
            offSet += MAX_ENCRYPT_BLOCK;
        } else {
            cache = cipher.doFinal(inputArray, offSet, inputLength - offSet);
            offSet = inputLength;
        }
        resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
        System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
    }
    return resultBytes;
}