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

最新推荐文章于 2024-05-05 21:30:34 发布
最新推荐文章于 2024-05-05 21:30:34 发布
阅读量759 收藏 4
点赞数
分类专栏： spring-cloud 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23945685/article/details/104836358
版权

最近有个简单需求，需要像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;
    }

}

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

 

java 一次性密码_TOTP算法 基于时间的一次性密码
weixin_35803480的博客
02-16 491
/**Copyright (c) 2011 IETF Trust and the persons identified asauthors of the code. All rights reserved.Redistribution and use in source and binary forms, with or withoutmodification, is permitted purs...
软件产品license的简单实现java
热门推荐
black_dawn的博客
03-15 1万+
软件产品License权限控制简单实现
jwt默认加密，过期时间，使用rsa加密demo
baidu_21349635的专栏
04-10 2202
文章目录1.默认加密调通:2.rsa加密方式调通demo: 1.默认加密调通: https://github.com/hufanglei/jwt-study/tree/jwt-HMAC256 springboot+mybatis+jwt+mysql 可以跑通试一下. 2.rsa加密方式调通demo: https://github.com/hufanglei/jwt-study 在master...
JWT非对称加密公私钥加解密可设置过期时间【Spring安全框架的JwtHelper】【jsonwebtoken.JJWT的Jwts】
竹林幽深
10-03 1251
rsa
java设置过期时间_java设置session过期时间的实现方法
weixin_32770423的博客
02-12 2589
本文实例讲述了java设置session过期时间的实现方法，分享给大家供大家参考。具体实现方法如下：1、Timeout in the deployment descriptor (web.xml)以分钟为单位20上面这种设置，对整个web应用生效。当客户端20分钟内都没有发起请求时，容器会将session干掉。2、Timeout with setMaxInactiveInterval()通过编码方...
java证书过期时间,在Java密钥库中检查证书的到期日期
weixin_36440198的博客
02-16 948
My java application uses a keystore file in which I have a certificate which is used in ssl connection with active directory server.What I have to do is to check its expiration date and prompt user if...
Java深入 - 对称加密/非对称加密/签名算法
自娱自乐的代码人
05-12 4402
对称加密：
java.security.InvalidKeyException: 无效密钥异常的正确解决方法，亲测有效，嘿嘿嘿
最新发布
PythonAigc的博客
05-05 6057
`java.security.InvalidKeyException` 异常通常发生在尝试使用加密算法时，但提供的密钥不符合该算法的要求或已经损坏。以下是对该异常的分析、原因、解决思路、以及包含代码示例的解决方法。 ### 问题分析 `InvalidKeyException` 异常表明在加密或解密操作中使用的密钥无效。这可能是因为密钥的类型、长度或格式不正确，或者密钥已经过期或损坏。 ### 报错原因 1. **密钥类型不匹配**：加密算法期望的是特定类型的密钥（如公钥、私钥、对称密钥等），但提供了
Java License生成与验证技术实现详解
本文将详细介绍Java环境下License文件的生成和验证机制实现，特别是采用非对称加密方法，即一对密钥（私钥和公钥）进行License文件的加密和解密处理。 ### Java License生成和验证机制的知识点： 1. **软件许可...
基于Java Web Token的单点登录技术研究与实现.pdf
12-31
JWT能避免跨站请求伪造攻击，构建简单并且所占空间并不是很大，还能通过加密函数验证内容是否被篡改，所以是目前比较理想跨域认证的实现方式。 JWT的形式一般诸如xxxxx.yyyyy.zzzzz的样子，对于xxxxx部分，一般有...
Java源码库buddy-auth.jwt-oidc实现OpenIDConnectID令牌验证
这种设计遵循了安全最佳实践，即公共的、非机密的客户端不应使用对称加密技术。 总结而言，此库为Java开发者提供了一种简便的方法来集成OpenID Connect和JWT技术，用以实现安全的用户身份验证功能。通过提供必要的...
Java实现Licence控制与KeyGenerator测试教程
- **加密算法**：生成 License 密钥时，通常会涉及加密算法，如 MD5、SHA 系列或者更安全的对称加密算法。加密技术确保了 License 的难以伪造性，提供了安全性保障。 - **软件许可模式**：开发者需要决定采用何种...
JDK自带方法实现RSA非对称加密
weixin_33762130的博客
06-04 372
1 package jdbc.pro.lin; 2 3 import java.security.InvalidKeyException; 4 import java.security.Key; 5 import java.security.KeyFactory; 6 import java.security.KeyPair; 7 import java.sec...
Java ssl证书过期_SSL证书过期问题解决
weixin_35537968的博客
02-27 1883
解决方法:1.用.cer 文件和.key 文件生成.p12 文件openssl pkcs12 -export -in /home/helen/cer2017.cer -inkey /home/helen/key2017.private.key -out /home/helen/server.p122.用.p12 文件生成..keystore 文件keytool -v -importkeystore...
Java加密技术（八）
【大漠孤烟】 的专栏
09-07 1143
本篇的主要内容为Java证书体系的实现。  请大家在阅读本篇内容时先阅读 Java加密技术（四），预先了解RSA加密算法。  在构建Java代码实现前，我们需要完成证书的制作。  1.生成keyStroe文件  在命令行下执行以下命令：  She
解决idea中BASE64Decoder和BASE64Encoder报错
WALTlife的博客
09-03 2784
无法解析符号 ''和'BASE64Decoder'：JDK中的/lib/tool.jar和/lib/rt.jar已经从Java SE 9中删除，所以在JDK9后，官方就已经不支持。
JDK1.8版本以上BASE64Encoder、BASE64Decoder报错
fk_d_st的博客
09-03 3063
JDK1.8版本以上BASE64Encoder、BASE64Decoder报错
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值