RsaHelper.java

package com.yanzuoguang.util.helper;

import com.yanzuoguang.util.YzgError;
import com.yanzuoguang.util.log.Log;
import org.springframework.util.Base64Utils;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * RSA
 * # 知识点
 * 1. 从一个固定长度的字节数组转换为另外一个固定长度的字节数组。如117的加密对应128的解密
 * 2. RSA分为公钥+私钥
 * 3. 可以用公钥加密+私钥解密 或者 私钥加密+公钥解密
 * 4. 因为加密只有字节，所以需要转换为base64
 * <p>
 * # 流程
 * 1. 生成公钥私钥
 * 2. 将公钥转换为字节,然后转换为base64字符串
 * 3. 将私钥转换为字节,然后转换为base64字符串
 * 4. 将来源字符串转换为字节，并按照固定加密长度截断，依次用公钥字符串生成的公钥进行加密。将加密后的字节转换为base64字符串。
 * 5. 将需要解密的字符串转换为字节，按照固定解密长度阶段，依次用私钥字符串生成的私钥进行解密。
 *
 * @author 颜佐光
 */
public final class RsaHelper {

    private static final String ALGORITHM_RSA = "RSA";

    private static final String ALGORITHM_SIGN = "MD5withRSA";

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

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

    private RsaHelper() {
        super();
    }

    private interface HandleBytes {
        byte[] handle(byte[] from, int offset, int len) throws Exception;
    }

    private static byte[] handle(byte[] froms, int size, HandleBytes handle) throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int inputLen = froms.length;
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > size) {
                cache = handle.handle(froms, offSet, size);
            } else {
                cache = handle.handle(froms, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * size;
        }
        byte[] to = out.toByteArray();
        out.close();
        return to;
    }

    /**
     * 生成密钥对
     */
    public static void generatorKeyPair() {
        try {
            RsaInfo rsaInfo = generatorRsa();
            Log.info(RsaHelper.class, "生成的公钥：%s\n生成的私钥：%s", rsaInfo.getPublicKey(), rsaInfo.getPrivateKey());
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 生成密钥对
     *
     * @return 返回值
     */
    public static RsaInfo generatorRsa() {
        try {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(ALGORITHM_RSA);
            keyPairGen.initialize(KEYPAIR_LEN);
            KeyPair keyPair = keyPairGen.generateKeyPair();
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

            return new RsaInfo(rsaPublicKey, rsaPrivateKey);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 获取公钥
     *
     * @return 公钥
     */
    public static PublicKey getPublicKey(String publicKey) {
        try {
            X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(decodeBase64(publicKey));
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
            return keyFactory.generatePublic(publicKeySpec);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 获取私钥
     *
     * @return 私钥
     */
    public static PrivateKey getPrivateKey(String privateKey) {
        try {
            PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(decodeBase64(privateKey));
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
            return keyFactory.generatePrivate(privateKeySpec);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 公钥加密,需要用私钥解密
     *
     * @param source       源代码
     * @param publicKeyStr 公钥base64字符串
     * @return 返回值
     */
    public static String encryptionByPublicKey(String source, String publicKeyStr) {
        PublicKey publicKey = getPublicKey(publicKeyStr);
        return encryptionByPublicKey(source, publicKey);
    }

    /**
     * 公钥加密,需要用私钥解密
     *
     * @param source    源代码
     * @param publicKey 公钥
     * @return 返回值
     */
    public static String encryptionByPublicKey(String source, PublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);

            byte[] bytes = source.getBytes(StandardCharsets.UTF_8);
            byte[] to = handle(bytes, MAX_ENCRYPT_BLOCK, cipher::doFinal);
            return encodeBase64(to);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 公钥解密,解密私钥加密的字符串
     *
     * @param target       私钥加密的值
     * @param publicKeyStr 公钥
     * @return 返回值
     */
    public static String decryptionByPublicKey(String target, String publicKeyStr) {
        PublicKey publicKey = getPublicKey(publicKeyStr);
        return decryptionByPublicKey(target, publicKey);
    }

    /**
     * 公钥解密,解密私钥加密的字符串
     *
     * @param target    私钥加密的值
     * @param publicKey 公钥
     * @return 返回值
     */
    public static String decryptionByPublicKey(String target, PublicKey publicKey) {
        try {
            byte[] bytes = decodeBase64(target);

            Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicKey);

            byte[] to = handle(bytes, MAX_DECRYPT_BLOCK, cipher::doFinal);
            return new String(to, StandardCharsets.UTF_8);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 公钥验证签名
     *
     * @param target       私钥加密的值
     * @param sign         签名
     * @param publicKeyStr 公钥
     * @return 返回值
     */
    public static boolean verifyByPublicKey(String target, String sign, String publicKeyStr) {
        PublicKey publicKey = getPublicKey(publicKeyStr);
        return verifyByPublicKey(target, sign, publicKey);
    }

    /**
     * 公钥验证签名
     *
     * @param target    私钥加密的值
     * @param sign      签名
     * @param publicKey 公钥
     * @return 返回值
     */
    public static boolean verifyByPublicKey(String target, String sign, PublicKey publicKey) {
        try {
            Signature signature = Signature.getInstance(ALGORITHM_SIGN);
            signature.initVerify(publicKey);
            signature.update(target.getBytes(StandardCharsets.UTF_8));
            return signature.verify(decodeBase64(sign));
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 私钥加密,要用公钥解密
     *
     * @param source        原字符串
     * @param privateKeyStr 私钥base64字符串
     * @return 返回值
     */
    public static String encryptionByPrivateKey(String source, String privateKeyStr) {
        PrivateKey privateKey = getPrivateKey(privateKeyStr);
        return encryptionByPrivateKey(source, privateKey);
    }

    /**
     * 私钥加密,要用公钥解密
     *
     * @param source     原字符串
     * @param privateKey 私钥
     * @return 返回值
     */
    public static String encryptionByPrivateKey(String source, PrivateKey privateKey) {
        try {
            byte[] bytes = source.getBytes(StandardCharsets.UTF_8);

            Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);

            byte[] to = handle(bytes, MAX_ENCRYPT_BLOCK, cipher::doFinal);

            return encodeBase64(to);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 私钥解密,解密公钥加密后的字符串
     *
     * @param target        加密字符
     * @param privateKeyStr base64位的私钥
     * @return 返回值
     */
    public static String decryptionByPrivateKey(String target, String privateKeyStr) {
        PrivateKey privateKey = getPrivateKey(privateKeyStr);
        return decryptionByPrivateKey(target, privateKey);
    }

    /**
     * 私钥解密,解密公钥加密后的字符串
     *
     * @param target     加密字符
     * @param privateKey 私钥
     * @return 返回值
     */
    public static String decryptionByPrivateKey(String target, PrivateKey privateKey) {
        try {
            byte[] bytes = decodeBase64(target);
            Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);

            byte[] to = handle(bytes, MAX_DECRYPT_BLOCK, cipher::doFinal);

            return new String(to, StandardCharsets.UTF_8);
        } catch (Exception ex) {
            throw YzgError.getRuntimeException(ex, "056", ex.getMessage());
        }
    }

    /**
     * 私钥签名
     *
     * @param target        原字符
     * @param privateKeyStr 私钥
     * @return 签名值
     */
    public static String signByPrivateKey(String target, String privateKeyStr) {
        PrivateKey privateKey = getPrivateKey(privateKeyStr);
        return signByPrivateKey(target, privateKey);
    }

    /**
     * 私钥签名
     *
     * @param target     原字符串
     * @param privateKey 私钥
     * @return 签名值
     */
    public static String signByPrivateKey(String target, PrivateKey privateKey) {
        try {
            Signature signature = Signature.getInstance(ALGORITHM_SIGN);
            signature.initSign(privateKey);
            signature.update(target.getBytes(StandardCharsets.UTF_8));
            return encodeBase64(signature.sign());
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * base64编码
     *
     * @param source 原字符
     * @return 编码
     */
    public static String encodeBase64(byte[] source) {
        try {
            byte[] to = Base64Utils.encode(source);
            return new String(to, StandardCharsets.UTF_8);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * Base64解码
     *
     * @param target 原字符
     * @return 解码
     */
    public static byte[] decodeBase64(String target) {
        try {
            byte[] from = target.getBytes(StandardCharsets.UTF_8);
            return Base64Utils.decode(from);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 解密信息
     *
     * @param rsaJsonPwd 加密后的json字符串
     * @param publicKey  公钥
     * @param timeout    超时时间
     * @return 返回值
     */
    public static String decodeRsaValueInfo(String rsaJsonPwd, PublicKey publicKey, long timeout) {
        String rsaJson = decryptionByPublicKey(rsaJsonPwd, publicKey);
        return checkTimeout(timeout, rsaJson);
    }

    /**
     * 解密信息
     *
     * @param rsaJsonPwd 加密后的json字符串
     * @param privateKey 私钥
     * @param timeout    超时时间
     * @return 返回值
     */
    public static String decodeRsaValueInfo(String rsaJsonPwd, PrivateKey privateKey, long timeout) {
        String rsaJson = decryptionByPrivateKey(rsaJsonPwd, privateKey);
        return checkTimeout(timeout, rsaJson);
    }

    private static String checkTimeout(long timeout, String rsaJson) {
        RsaValueInfo rsaValueInfo = JsonHelper.deserialize(rsaJson, RsaValueInfo.class);
        long splitTime = System.currentTimeMillis() / 1000 - rsaValueInfo.getT();
        if (splitTime > timeout && timeout > 0) {
            throw YzgError.getRuntimeException("999");
        }
        return rsaValueInfo.getV();
    }

    /**
     * 解密信息
     *
     * @param value     私钥
     * @param publicKey 公钥
     * @return 返回值
     */
    public static String encodeRsaValueInfo(String value, PublicKey publicKey) {
        RsaValueInfo info = new RsaValueInfo(value);
        String json = JsonHelper.serialize(info);
        return encryptionByPublicKey(json, publicKey);
    }

    /**
     * 解密信息
     *
     * @param value      私钥
     * @param privateKey 私钥
     * @return 返回值
     */
    public static String encodeRsaValueInfo(String value, PrivateKey privateKey) {
        RsaValueInfo info = new RsaValueInfo(value);
        String json = JsonHelper.serialize(info);
        return encryptionByPrivateKey(json, privateKey);

    }

    /**
     * RSA加密值信息
     */
    public static class RsaValueInfo {
        /**
         * 加密值
         */
        private String v;
        /**
         * Linux时间错(秒)
         */
        private long t = System.currentTimeMillis() / 1000;

        public RsaValueInfo(String v) {
            this.v = v;
        }

        public RsaValueInfo(String v, long t) {
            this.v = v;
            this.t = t;
        }

        public String getV() {
            return v;
        }

        public void setV(String v) {
            this.v = v;
        }

        public long getT() {
            return t;
        }

        public void setT(long t) {
            this.t = t;
        }
    }

    /**
     * RSA公钥信息
     */
    public static class RsaInfo {
        /**
         * 公钥
         */
        private PublicKey publicKeyFrom;
        /**
         * 私钥
         */
        private PrivateKey privateKeyFrom;
        /**
         * 公钥
         */
        private String publicKey;
        /**
         * 私钥
         */
        private String privateKey;

        public RsaInfo() {
        }

        public RsaInfo(PublicKey publicKeyFrom, PrivateKey privateKeyFrom) {
            this.publicKeyFrom = publicKeyFrom;
            this.privateKeyFrom = privateKeyFrom;
            this.initToWithFrom();
        }

        public RsaInfo(String publicKey, String privateKey) {
            this.publicKey = publicKey;
            this.privateKey = privateKey;
            this.initFromWithTo();
        }

        public void initToWithFrom() {
            this.publicKey = encodeBase64(this.publicKeyFrom.getEncoded());
            this.privateKey = encodeBase64(this.privateKeyFrom.getEncoded());
        }

        public void initFromWithTo() {
            this.publicKeyFrom = RsaHelper.getPublicKey(this.publicKey);
            this.privateKeyFrom = RsaHelper.getPrivateKey(this.privateKey);
        }

        public PublicKey getPublicKeyFrom() {
            return publicKeyFrom;
        }

        public void setPublicKeyFrom(PublicKey publicKeyFrom) {
            this.publicKeyFrom = publicKeyFrom;
        }

        public PrivateKey getPrivateKeyFrom() {
            return privateKeyFrom;
        }

        public void setPrivateKeyFrom(PrivateKey privateKeyFrom) {
            this.privateKeyFrom = privateKeyFrom;
        }

        public String getPublicKey() {
            return publicKey;
        }

        public void setPublicKey(String publicKey) {
            this.publicKey = publicKey;
        }

        public String getPrivateKey() {
            return privateKey;
        }

        public void setPrivateKey(String privateKey) {
            this.privateKey = privateKey;
        }
    }
}