java RSA 非对称 私钥 密钥 加密解密工具类

先决条件

使用了apache commons-codec进行base64编码

<dependency>
  <groupId>commons-codec</groupId>
  <artifactId>commons-codec</artifactId>
  <version>1.11</version>
</dependency>

apache commons-codec

工具类

复制粘贴，引入依赖即可

/**
 * RSA工具类。
 *
 *         RSAUtils.RSAKey key = RSAUtils.createRSAKey("任意的字符,最好是这样的QWEqwsf1235325$%^&*@#@");//创建钥匙
 *         String prkey = key.getPrivateKey();
 *         String pukey = key.getPublicKey();
 *         String testMaMa = "逆水行舟，也能随时驻留原地，戒躁。";
 *         String encrypt = RSAUtils.encrypt(pukey, testMaMa);//加密
 *         String decrypt = RSAUtils.decrypt(prkey, encrypt);//解密
 *
 * @author chenzhonghua
 * @date 2018/6/22
 */
public class RSAUtils {
    private static final String RSA = "RSA";

    public static final int DF_SIZE=1024;

    private RSAUtils() {
        throw new IllegalAccessError("this is a utils");
    }

    /**
     * 生成RSA钥匙
     *
     * @param random 钥匙种子
     * @return RSA钥匙
     */
    public static RSAKey createRSAKey(String random,int size) {
        Objects.requireNonNull(random, "random不能为Null");
        Objects.requireNonNull(size, "size不能为Null");
        KeyPairGenerator rsa;
        try {
            rsa = KeyPairGenerator.getInstance(RSA);
        } catch (NoSuchAlgorithmException e) {
            throw new RSAException("没有找到" + RSA + "标准算法", e);
        }
        rsa.initialize(size, new SecureRandom(random.getBytes()));
        KeyPair keyPair = rsa.generateKeyPair();
        return new RSAKey(Base64.encodeBase64String(keyPair.getPrivate().getEncoded()), Base64.encodeBase64String(keyPair.getPublic().getEncoded()));

    }

    /**
     * 生成RSA钥匙
     *
     * @param random 钥匙种子
     * @return RSA钥匙
     */
    public static RSAKey createRSAKey(String random) {
        return createRSAKey(random,DF_SIZE);
    }

    /**
     * 还原base64 的公钥
     *
     * @param publicKey 公钥
     * @return 公钥
     */
    public static PublicKey getPulicKey(String publicKey) {
        Objects.requireNonNull(publicKey, "publicKey不能为Null");
        try {
            return KeyFactory.getInstance(RSA).generatePublic(new X509EncodedKeySpec(Base64.decodeBase64(publicKey)));
        } catch (InvalidKeySpecException e) {
            throw new RSAException("publicKey:" + publicKey + "无效", e);
        } catch (NoSuchAlgorithmException e) {
            throw new RSAException("没有找到" + RSA + "标准算法", e);
        }
    }

    /**
     * 还原base64 的私钥
     *
     * @param privateKey 私钥
     * @return 私钥
     */
    public static PrivateKey getPrivateKey(String privateKey) {
        Objects.requireNonNull(privateKey, "privateKey不能为Null");
        try {
            return KeyFactory.getInstance(RSA).generatePrivate(new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey)));
        } catch (InvalidKeySpecException e) {
            throw new RSAException("privateKey:" + privateKey + "无效", e);
        } catch (NoSuchAlgorithmException e) {
            throw new RSAException("没有找到" + RSA + "标准算法", e);
        }
    }

    /**该方法会尝试先去构建私钥，私钥构建失败就回去尝试构建公钥。
     * @param key 钥匙base64
     * @return 钥匙
     */
    public static Key getKey(String key) {
        try {
            return getPrivateKey(key);
        }catch (Exception e){
            return getPulicKey(key);
        }
    }

    /**加密
     * @param key 钥匙
     * @param data 数据
     * @return 加密后的base64
     */
    public static String encrypt(String key, String data) {
        return encrypt(getKey(key),data);
    }

    /**加密
     * @param key 钥匙
     * @param data 数据
     * @return 加密后的base64
     */
    public static String encrypt(Key key, String data) {
        Objects.requireNonNull(key, "key不能为Null");
        Objects.requireNonNull(data, "data不能为Null");
        try {
            Cipher cipher = Cipher.getInstance(RSA);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            return Base64.encodeBase64String(cipher.doFinal(data.getBytes()));
        } catch (Exception e) {
            throw new RSAException("RSA加密失败", e);
        }
    }

    /**解密
     * @param key 钥匙
     * @param data 密文(base64)
     * @return 明文
     */
    public static String decrypt(String  key, String data) {
        return decrypt(getKey(key),data);
    }

    /**解密
     * @param key 钥匙
     * @param data 密文(base64)
     * @return 明文
     */
    public static String decrypt(Key key, String data) {
        Objects.requireNonNull(key, "key不能为Null");
        Objects.requireNonNull(data, "data不能为Null");
        try {
            Cipher cipher = Cipher.getInstance(RSA);
            cipher.init(Cipher.DECRYPT_MODE, key);
            return new String(cipher.doFinal(Base64.decodeBase64(data)));
        } catch (Exception e) {
            throw new RSAException("RSA解密失败", e);
        }
    }


    /**
     * RSA钥匙对象
     */
    public static class RSAKey {
        private String privateKey;

        private String publicKey;

        private RSAKey(String privateKey, String publicKey) {
            this.privateKey = privateKey;
            this.publicKey = publicKey;
        }

        public String getPrivateKey() {
            return privateKey;
        }

        public String getPublicKey() {
            return publicKey;
        }
    }

    /**
     * RSA操作异常
     */
    public static class RSAException extends RuntimeException {
         RSAException(String message, Throwable cause) {
            super(message, cause);
        }
    }
}

示例

code:

    public static void main(String[] args){
        RSAUtils.RSAKey key = RSAUtils.createRSAKey("任意的字符,最好是这样的QWEqwsf1235325$%^&*@#@");//创建钥匙
        String prkey = key.getPrivateKey();
        String pukey = key.getPublicKey();
        System.out.println("私钥:" + prkey);
        System.out.println("公钥:" + pukey);
        String testMaMa = "逆水行舟，也能随时驻留原地，戒躁。";
        System.out.println("原文:" + testMaMa);
        String encrypt = RSAUtils.encrypt(pukey, testMaMa);//加密
        System.out.println("密文:" + encrypt);
        String decrypt = RSAUtils.decrypt(prkey, encrypt);//解密
        System.out.println("明文:" + decrypt);
    }

结果:

私钥:MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAJCehN++3gG+VnQoxsshw7XvXiq0b3IOmBm3AMA2SU87UzYbRVCwhXDap6ohWbt8tyWvuRvTTzMf33UETFv0tpxb52EP9h4N0gkf8u77c9zgiPfYe4MrlkSWu/aViBcUbxfSPs90bDKivbBMIB2KePQEv0HpqCgmwUfBd2CeSvTpAgMBAAECgYACTlTGEJAPrQ5J2eCZmpc5TnDM84WXZv4r4swjRHpUxhhkk3i+eaIXE5V60/9PSwTMmAm2lN79bLOudPwWt0c2HqpMJRg0brbODKyz8NwadlMLWTD3fjHi2VEngC4vG8JiHmebjwbR7ETTDQMLPoiRvPM6u8bF64pT/bOIYVzM5QJBAP+o6thtKKRD4fCdfPvI9+U5iJUdb0ANczO4w/vUmE8QLSq2KTpb9n9YMNjlaw0GaSXK8L7sqi1Pnkh2AC/lVS8CQQCQz8dz9VqbeOXnXxf0Y0hWUTrH0oTQfoSo1HOumfJp383Ml5oRTfsypZpwBXmDnhTpAZ+OzbHVIHHbHMtEN4FnAkEA3Lzy8CTnx1SZGxBPXnH5n6AaTm1Ypdw3EHxCMwgu7WzRIqSfWjUW0oLJwivrTxau6KOdU6uxj2fECVpg9Pm0nwJBAI7KMtOmhPd02M2yOL6j/zoN0rYiYQ/tEQYgpwjth9jZ8+XfPu39RMqF/Kik3VLo15mCHkEDlmyfF2WFGPFlAdUCQHbvH3L+fofY8CjajBB7cIUQNNswuFsunwTsA1eI+iVNihdx0OaEJNSqaeiTFsk++sbeYjYmmG61msgoPJeYCwc=
公钥:MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCQnoTfvt4BvlZ0KMbLIcO1714qtG9yDpgZtwDANklPO1M2G0VQsIVw2qeqIVm7fLclr7kb008zH991BExb9LacW+dhD/YeDdIJH/Lu+3Pc4Ij32HuDK5ZElrv2lYgXFG8X0j7PdGwyor2wTCAdinj0BL9B6agoJsFHwXdgnkr06QIDAQAB
原文:逆水行舟，也能随时驻留原地，戒躁。
密文:YVR7l6/tvgksyz0fWUNbJgZ9PBbSEqerRrRrs+BFgsiQ3AcukRxSvnUkZqM7ueDmg1FdYiHRYWQGwvltbWQrxwrgnR+s7aCv9YG9mV12Mw1F0nf/SJ0TnVg92lD2r+4O7nWKqs7CCOtKlChuIRBpOTacHHnA0BQbcGC/QAw75nU=
明文:逆水行舟，也能随时驻留原地，戒躁。