java非对称加密实现到期验证

绝地灬酷狼 2023-07-13 15:25 23阅读 0赞

最近有个简单需求，需要像c端一样有一个到期秘钥的需求

上代码：

（获取验秘钥）

import org.bouncycastle.jce.provider.BouncyCastleProvider;
    import org.springframework.stereotype.Service;
    import org.springframework.util.StringUtils;
    import sun.misc.BASE64Decoder;
    
    import javax.annotation.PostConstruct;
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    import java.io.IOException;
    import java.security.*;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    
    @Service
    public class RSAEncrypt {
    
        private final String DEFAULT_PUBLIC_KEY = "";
        private final String DEFAULT_PRIVATE_KEY = "";
    
        /**
         * 私钥
         */
        private RSAPrivateKey privateKey;
    
        /**
         * 公钥
         */
        private RSAPublicKey publicKey;
    
        /**
         * 字节数据转字符串专用集合
         */
        private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
    
        @PostConstruct
        public void init() {
            genKeyPair();
    
            //加载公钥
            try {
                loadPublicKey(DEFAULT_PUBLIC_KEY);
                System.out.println("加载公钥成功");
            } catch (Exception e) {
                System.err.println(e.getMessage());
                System.err.println("加载公钥失败");
            }
    
            //加载私钥
            try {
                loadPrivateKey(DEFAULT_PRIVATE_KEY);
                System.out.println("加载私钥成功");
            } catch (Exception e) {
                System.err.println(e.getMessage());
                System.err.println("加载私钥失败");
            }
        }
    
    
        /**
         * 随机生成密钥对
         */
        public void genKeyPair() {
            KeyPairGenerator keyPairGen = null;
            try {
                keyPairGen = KeyPairGenerator.getInstance("RSA");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            keyPairGen.initialize(1024, new SecureRandom());
            KeyPair keyPair = keyPairGen.generateKeyPair();
            this.privateKey = (RSAPrivateKey) keyPair.getPrivate();
            this.publicKey = (RSAPublicKey) keyPair.getPublic();
            System.out.println("公钥：" + keyPair.getPrivate());
            System.out.println("私钥：" + keyPair.getPublic());
        }
    
        /**
         * 从字符串中加载公钥
         *
         * @param publicKeyStr 公钥数据字符串
         * @throws Exception 加载公钥时产生的异常
         */
        private void loadPublicKey(String publicKeyStr) throws Exception {
            try {
                BASE64Decoder base64Decoder = new BASE64Decoder();
                byte[] buffer = base64Decoder.decodeBuffer(publicKeyStr);
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
                publicKey = (RSAPublicKey) keyFactory.generatePublic(keySpec);
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此算法");
            } catch (InvalidKeySpecException e) {
                throw new Exception("公钥非法");
            } catch (IOException e) {
                throw new Exception("公钥数据内容读取错误");
            } catch (NullPointerException e) {
                throw new Exception("公钥数据为空");
            }
        }
    
        private void loadPrivateKey(String privateKeyStr) throws Exception {
            try {
                BASE64Decoder base64Decoder = new BASE64Decoder();
                byte[] buffer = base64Decoder.decodeBuffer(privateKeyStr);
                PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                privateKey = (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此算法");
            } catch (InvalidKeySpecException e) {
                throw new Exception("私钥非法");
            } catch (IOException e) {
                throw new Exception("私钥数据内容读取错误");
            } catch (NullPointerException e) {
                throw new Exception("私钥数据为空");
            }
        }
    
        /**
         * 加密过程
         *
         * @param publicKey     公钥
         * @param plainTextData 明文数据
         * @return
         * @throws Exception 加密过程中的异常信息
         */
        public byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception {
            if (publicKey == null) {
                throw new Exception("加密公钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                cipher = Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                byte[] output = cipher.doFinal(plainTextData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此加密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("加密公钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("明文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("明文数据已损坏");
            }
        }
    
        /**
         * 加密过程
         *
         * @param privateKey    私钥
         * @param plainTextData 明文数据
         * @return
         * @throws Exception 加密过程中的异常信息
         */
        public byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData) throws Exception {
            if (privateKey == null) {
                throw new Exception("加密公钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                cipher = Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.ENCRYPT_MODE, privateKey);
                byte[] output = cipher.doFinal(plainTextData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此加密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("加密私钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("明文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("明文数据已损坏");
            }
        }
    
        /**
         * 解密过程
         *
         * @param privateKey 私钥
         * @param cipherData 密文数据
         * @return 明文
         * @throws Exception 解密过程中的异常信息
         */
        public byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) throws Exception {
            if (privateKey == null) {
                throw new Exception("解密私钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                cipher = Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                byte[] output = cipher.doFinal(cipherData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此解密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("解密私钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("密文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("密文数据已损坏");
            }
        }
    
        /**
         * 解密过程
         *
         * @param publicKey  公钥
         * @param cipherData 密文数据
         * @return 明文
         * @throws Exception 解密过程中的异常信息
         */
        private byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData) throws Exception {
            if (publicKey == null) {
                throw new Exception("解密私钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                cipher = Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                byte[] output = cipher.doFinal(cipherData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此解密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("解密私钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("密文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("密文数据已损坏");
            }
        }
    
        /**
         * 字节数据转十六进制字符串
         *
         * @param data 输入数据
         * @return 十六进制内容
         */
        private String byteArrayToString(byte[] data) {
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < data.length; i++) {
                //取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
                stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
                //取出字节的低四位 作为索引得到相应的十六进制标识符
                stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
                if (i < data.length - 1) {
    //                stringBuilder.append(' ');
                }
            }
            return stringBuilder.toString();
        }
    
        private byte[] hexStringToBytes(String hexString) {
            if (StringUtils.isEmpty(hexString)) {
                return null;
            }
            hexString = hexString.toLowerCase();
            final byte[] byteArray = new byte[hexString.length() >> 1];
            int index = 0;
            for (int i = 0; i < hexString.length(); i++) {
                if (index > hexString.length() - 1) {
                    return byteArray;
                }
                byte highDit = (byte) (Character.digit(hexString.charAt(index), 16) & 0xFF);
                byte lowDit = (byte) (Character.digit(hexString.charAt(index + 1), 16) & 0xFF);
                byteArray[i] = (byte) (highDit << 4 | lowDit);
                index += 2;
            }
            return byteArray;
        }
    
        public String encrypt(String str) throws Exception {
            byte[] cipher = encrypt(privateKey, str.getBytes());
            System.out.println("密文长度:" + cipher.length);
            System.out.println("密文：");
            String ret = byteArrayToString(cipher);
            System.out.println(ret);
            return ret;
        }
    
    
    //    public static void main(String[] args){
    //        RSAEncrypt rsaEncrypt= new RSAEncrypt();
    //        rsaEncrypt.genKeyPair();
    //
    //
    //        //加载公钥
    //        try {
    //            rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);
    //            System.out.println("加载公钥成功");
    //        } catch (Exception e) {
    //            System.err.println(e.getMessage());
    //            System.err.println("加载公钥失败");
    //        }
    //
    //        //加载私钥
    //        try {
    //            rsaEncrypt.loadPrivateKey(RSAEncrypt.DEFAULT_PRIVATE_KEY);
    //            System.out.println("加载私钥成功");
    //        } catch (Exception e) {
    //            System.err.println(e.getMessage());
    //            System.err.println("加载私钥失败");
    //        }
    //
    //        //测试字符串
    //        String encryptStr= "{\"overdue\":1569859199000,\"reqTime\":1564644369000,\"ip\":\"10.83.194.49\",\"username\":\"shangqi\"}";
    //
    //        try {
    //            //加密
    //            byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPrivateKey(), encryptStr.getBytes());
    //            //解密
    //            byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPublicKey(), cipher);
    //            System.out.println("密文长度:"+ cipher.length);
    //            System.out.println("密文：");
    //            System.out.println(RSAEncrypt.byteArrayToString(cipher));
    //            System.out.println("明文长度:"+ plainText.length);
    //            System.out.println(RSAEncrypt.byteArrayToString(plainText));
    //            System.out.println(new String(plainText));
    //        } catch (Exception e) {
    //            System.err.println(e.getMessage());
    //        }
    //
    //
    //        String str = "5a354671e624865cdbff7ecf2eae72f72c2b8a2b7b9f744dfc4b8a2f8b1650efe3807bc0f3d4ca79f4f6116d87bd988c6afa27a2b5e0a0a86d938a1cd7332665749314cb5386c82c2b36f21364ddc66416897fddb04c1359ba92e2015caba2d077235b59e87b5bdf3236ab79578ade6b07672fa8ec52d5ccc892af7041d2edd4";
    //        try {
    //            byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPublicKey(), hexStringToBytes(str));
    //            System.out.println(new String(plainText));
    //        } catch (Exception e) {
    //            System.err.println(e.getMessage());
    //        }
    //
    //    }

（解密秘钥）

import org.bouncycastle.jce.provider.BouncyCastleProvider;
    import org.springframework.stereotype.Component;
    import sun.misc.BASE64Decoder;
    
    import javax.annotation.PostConstruct;
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    import java.io.IOException;
    import java.security.*;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.X509EncodedKeySpec;
    
    /**
     * 认证信息解密
     * @author zf
     * @since 2019/8/1
     */
    @Component
    public class LicenceUtils {
    
        private static final String PUBLIC_KEY ="";
        private RSAPublicKey publicKey;
    
        @PostConstruct
        private void init() {
            KeyPairGenerator keyPairGen = null;
            try {
                keyPairGen= KeyPairGenerator.getInstance("RSA");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            keyPairGen.initialize(1024, new SecureRandom());
            KeyPair keyPair = keyPairGen.generateKeyPair();
            this.publicKey = (RSAPublicKey) keyPair.getPublic();
    
            //加载公钥
            try {
                loadPublicKey(PUBLIC_KEY);
                System.out.println("加载公钥成功");
            } catch (Exception e) {
                System.err.println(e.getMessage());
                System.err.println("加载公钥失败");
            }
        }
    
        /**
         * 从字符串中加载公钥
         * @param publicKeyStr 公钥数据字符串
         * @throws Exception 加载公钥时产生的异常
         */
        private void loadPublicKey(String publicKeyStr) throws Exception{
            try {
                BASE64Decoder base64Decoder= new BASE64Decoder();
                byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);
                KeyFactory keyFactory= KeyFactory.getInstance("RSA");
                X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);
                this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此算法");
            } catch (InvalidKeySpecException e) {
                throw new Exception("公钥非法");
            } catch (IOException e) {
                throw new Exception("公钥数据内容读取错误");
            } catch (NullPointerException e) {
                throw new Exception("公钥数据为空");
            }
        }
    
        /**
         * 解密过程
         * @param publicKey 公钥
         * @param cipherData 密文数据
         * @return 明文
         * @throws Exception 解密过程中的异常信息
         */
        private byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData) throws Exception{
            if (publicKey== null){
                throw new Exception("解密私钥为空, 请设置");
            }
            Cipher cipher= null;
            try {
                cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                byte[] output= cipher.doFinal(cipherData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此解密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            }catch (InvalidKeyException e) {
                throw new Exception("解密私钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("密文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("密文数据已损坏");
            }
        }
    
        public String decrypt(String hexStr) {
            try {
                byte[] plainText = decrypt(publicKey, hexStringToBytes(hexStr));
                return new String(plainText);
            } catch (Exception e) {
                System.err.println(e.getMessage());
                return null;
            }
        }
    
        private byte[] hexStringToBytes(String hexString) {
            if (StringUtil.isEmpty(hexString)) {
                return null;
            }
            hexString = hexString.toLowerCase();
            final byte[] byteArray = new byte[hexString.length() >> 1];
            int index = 0;
            for (int i = 0; i < hexString.length(); i++) {
                if (index  > hexString.length() - 1) {
                    return byteArray;
                }
                byte highDit = (byte) (Character.digit(hexString.charAt(index), 16) & 0xFF);
                byte lowDit = (byte) (Character.digit(hexString.charAt(index + 1), 16) & 0xFF);
                byteArray[i] = (byte) (highDit << 4 | lowDit);
                index += 2;
            }
            return byteArray;
        }
    
    }

最后统一访问认证源的时间判断该秘钥是否过期