JWT（2）JWT的加密算法

已于 2024-09-24 08:58:14 修改
阅读量442 收藏 9
点赞数 4
分类专栏： 安全 文章标签： 安全
于 2024-07-18 17:59:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_t_y_y/article/details/140529652
版权

前言

1、jwt加密算法

JWT（JSON Web Token）支持多种加密和签名算法，用于确保JWT在传输过程中不被篡改，这些算法用于确保Token的安全性和数据的完整性。见Algorithm ：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.auth0.jwt.algorithms;

import com.auth0.jwt.exceptions.SignatureGenerationException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.auth0.jwt.interfaces.ECDSAKeyProvider;
import com.auth0.jwt.interfaces.RSAKeyProvider;
import java.security.interfaces.ECKey;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.interfaces.RSAKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;

public abstract class Algorithm {
    private final String name;
    private final String description;

    public static Algorithm RSA256(RSAKeyProvider keyProvider) throws IllegalArgumentException {
        return new RSAAlgorithm("RS256", "SHA256withRSA", keyProvider);
    }

    public static Algorithm RSA256(RSAPublicKey publicKey, RSAPrivateKey privateKey) throws IllegalArgumentException {
        return RSA256(RSAAlgorithm.providerForKeys(publicKey, privateKey));
    }

    /** @deprecated */
    @Deprecated
    public static Algorithm RSA256(RSAKey key) throws IllegalArgumentException {
        RSAPublicKey publicKey = key instanceof RSAPublicKey ? (RSAPublicKey)key : null;
        RSAPrivateKey privateKey = key instanceof RSAPrivateKey ? (RSAPrivateKey)key : null;
        return RSA256(publicKey, privateKey);
    }

    public static Algorithm RSA384(RSAKeyProvider keyProvider) throws IllegalArgumentException {
        return new RSAAlgorithm("RS384", "SHA384withRSA", keyProvider);
    }

    public static Algorithm RSA384(RSAPublicKey publicKey, RSAPrivateKey privateKey) throws IllegalArgumentException {
        return RSA384(RSAAlgorithm.providerForKeys(publicKey, privateKey));
    }

    /** @deprecated */
    @Deprecated
    public static Algorithm RSA384(RSAKey key) throws IllegalArgumentException {
        RSAPublicKey publicKey = key instanceof RSAPublicKey ? (RSAPublicKey)key : null;
        RSAPrivateKey privateKey = key instanceof RSAPrivateKey ? (RSAPrivateKey)key : null;
        return RSA384(publicKey, privateKey);
    }

    public static Algorithm RSA512(RSAKeyProvider keyProvider) throws IllegalArgumentException {
        return new RSAAlgorithm("RS512", "SHA512withRSA", keyProvider);
    }

    public static Algorithm RSA512(RSAPublicKey publicKey, RSAPrivateKey privateKey) throws IllegalArgumentException {
        return RSA512(RSAAlgorithm.providerForKeys(publicKey, privateKey));
    }

    /** @deprecated */
    @Deprecated
    public static Algorithm RSA512(RSAKey key) throws IllegalArgumentException {
        RSAPublicKey publicKey = key instanceof RSAPublicKey ? (RSAPublicKey)key : null;
        RSAPrivateKey privateKey = key instanceof RSAPrivateKey ? (RSAPrivateKey)key : null;
        return RSA512(publicKey, privateKey);
    }

    public static Algorithm HMAC256(String secret) throws IllegalArgumentException {
        return new HMACAlgorithm("HS256", "HmacSHA256", secret);
    }

    public static Algorithm HMAC384(String secret) throws IllegalArgumentException {
        return new HMACAlgorithm("HS384", "HmacSHA384", secret);
    }

    public static Algorithm HMAC512(String secret) throws IllegalArgumentException {
        return new HMACAlgorithm("HS512", "HmacSHA512", secret);
    }

    public static Algorithm HMAC256(byte[] secret) throws IllegalArgumentException {
        return new HMACAlgorithm("HS256", "HmacSHA256", secret);
    }

    public static Algorithm HMAC384(byte[] secret) throws IllegalArgumentException {
        return new HMACAlgorithm("HS384", "HmacSHA384", secret);
    }

    public static Algorithm HMAC512(byte[] secret) throws IllegalArgumentException {
        return new HMACAlgorithm("HS512", "HmacSHA512", secret);
    }

    public static Algorithm ECDSA256(ECDSAKeyProvider keyProvider) throws IllegalArgumentException {
        return new ECDSAAlgorithm("ES256", "SHA256withECDSA", 32, keyProvider);
    }

    public static Algorithm ECDSA256(ECPublicKey publicKey, ECPrivateKey privateKey) throws IllegalArgumentException {
        return ECDSA256(ECDSAAlgorithm.providerForKeys(publicKey, privateKey));
    }

    /** @deprecated */
    @Deprecated
    public static Algorithm ECDSA256(ECKey key) throws IllegalArgumentException {
        ECPublicKey publicKey = key instanceof ECPublicKey ? (ECPublicKey)key : null;
        ECPrivateKey privateKey = key instanceof ECPrivateKey ? (ECPrivateKey)key : null;
        return ECDSA256(publicKey, privateKey);
    }

    public static Algorithm ECDSA384(ECDSAKeyProvider keyProvider) throws IllegalArgumentException {
        return new ECDSAAlgorithm("ES384", "SHA384withECDSA", 48, keyProvider);
    }

    public static Algorithm ECDSA384(ECPublicKey publicKey, ECPrivateKey privateKey) throws IllegalArgumentException {
        return ECDSA384(ECDSAAlgorithm.providerForKeys(publicKey, privateKey));
    }

    /** @deprecated */
    @Deprecated
    public static Algorithm ECDSA384(ECKey key) throws IllegalArgumentException {
        ECPublicKey publicKey = key instanceof ECPublicKey ? (ECPublicKey)key : null;
        ECPrivateKey privateKey = key instanceof ECPrivateKey ? (ECPrivateKey)key : null;
        return ECDSA384(publicKey, privateKey);
    }

    public static Algorithm ECDSA512(ECDSAKeyProvider keyProvider) throws IllegalArgumentException {
        return new ECDSAAlgorithm("ES512", "SHA512withECDSA", 66, keyProvider);
    }

    public static Algorithm ECDSA512(ECPublicKey publicKey, ECPrivateKey privateKey) throws IllegalArgumentException {
        return ECDSA512(ECDSAAlgorithm.providerForKeys(publicKey, privateKey));
    }

    /** @deprecated */
    @Deprecated
    public static Algorithm ECDSA512(ECKey key) throws IllegalArgumentException {
        ECPublicKey publicKey = key instanceof ECPublicKey ? (ECPublicKey)key : null;
        ECPrivateKey privateKey = key instanceof ECPrivateKey ? (ECPrivateKey)key : null;
        return ECDSA512(publicKey, privateKey);
    }

    public static Algorithm none() {
        return new NoneAlgorithm();
    }

    protected Algorithm(String name, String description) {
        this.name = name;
        this.description = description;
    }

    public String getSigningKeyId() {
        return null;
    }

    public String getName() {
        return this.name;
    }

    String getDescription() {
        return this.description;
    }

    public String toString() {
        return this.description;
    }

    public abstract void verify(DecodedJWT var1) throws SignatureVerificationException;

    public byte[] sign(byte[] headerBytes, byte[] payloadBytes) throws SignatureGenerationException {
        byte[] contentBytes = new byte[headerBytes.length + 1 + payloadBytes.length];
        System.arraycopy(headerBytes, 0, contentBytes, 0, headerBytes.length);
        contentBytes[headerBytes.length] = 46;
        System.arraycopy(payloadBytes, 0, contentBytes, headerBytes.length + 1, payloadBytes.length);
        return this.sign(contentBytes);
    }

    /** @deprecated */
    @Deprecated
    public abstract byte[] sign(byte[] var1) throws SignatureGenerationException;
}
2、jwt算法分类

1）HMAC属于对称加密：

这些算法使用同一个密钥（secret_key）进行签名和验证，属于对称加密。一旦密钥泄露，安全性就会受到威胁。适用于信任的系统内部，例如单体应用或集中式认证服务。

2）RSA和ECDSA算法属于非对称加密：

使用一对密钥，公钥用于验证，私钥用于签名，提供了更好的密钥管理和分发机制，即使公钥被泄露，只要私钥保持安全，Token依然是安全的。适用于分布式系统和多服务环境。

如我们项目曾经将HS256升级为ES256。

3、jwt算法比较

1）性能：

对称加密算法通常比非对称加密算法更快，但在分布式系统中，非对称加密算法（尤其是ECDSA）更受欢迎，因为它们提供了更好的安全性和灵活性。如我们项目曾将jwt由HS256升级为ES256。

2）Token大小：

非对称加密算法生成的签名通常比对称加密算法的签名要大，但ECDSA算法由于其较短的签名长度，可以在保持安全性的同时减少Token的大小。在选择JWT的加密算法时，需要根据系统的具体需求和安全要求来决定使用哪种算法。对于需要跨多个服务或不信任环境传输的Token，推荐使用非对称加密算法，如RS256或ES256。

一、HMAC算法（Hash-based Message Authentication Code）：

1、HS256
1.1、介绍

HS256算法使用了HMAC-SHA256算法，其中HMAC代表散列消息认证码，SHA256是一种散列函数，能够为任意长度的数据生成一个固定长度的摘要。

HS256的工作原理是：

使用一个密钥和一个消息作为输入；使用SHA-256散列函数来计算消息的摘要；使用HMAC（散列消息认证码）函数，结合散列函数和密钥，来生成一个密钥相关的摘要。

1.2、demo
package com.demo.security.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.demo.security.constant.UserConstants;
import com.demo.security.entity.UserEntity;
import lombok.extern.slf4j.Slf4j;

import java.util.Date;
import java.util.Map;
@Slf4j
public class JwtUtilTest {

    public static void main(String[] args) {
        //1、生成token
        String username = "zs";
        Integer age = 18;
        String key = "123456";
        Algorithm algorithm = Algorithm.HMAC256(key);
        UserEntity userEntity = UserEntity.builder()
                .username(username)
                .age(age)
                .build();
        String token = getToken(userEntity,algorithm);
        log.info("token获取成功:{}",token);
        log.info("token长度:{}",token.length());
        //2、验证token，因为只要token是jwt，第三步一定会成功，这里是为了验证是不是我生成的，防止攻击
        JWTVerifier verifier = JWT.require(algorithm).build();
        verifier.verify(token);
        //3、解析token
        UserEntity tokenUser = getUser(token);
        if(username.equals(tokenUser.getUsername())){
            log.info("解析成功");
        }
    }

    public static UserEntity getUser( String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            Map<String, Claim> claims = jwt.getClaims();
            String username = claims.get("username").asString();
            int age = claims.get("age").asInt();
            return UserEntity.builder()
                    .username(username)
                    .age(age)
                    .build();
        } catch (JWTDecodeException e) {
            return null;
        }
    }

    /**
     * 生成签名,5min(分钟)后过期
     * @return 加密的token
     */
    public static String getToken(UserEntity userEntity, Algorithm algorithm) {
        Date date = new Date(System.currentTimeMillis() + UserConstants.EXPIRE_TIME);
        // 附带username信息
        return JWT.create()
                //iss：签发方
                .withIssuer("wtyy")
                //aud：接收jwt的一方
                .withAudience("web-demo")
                //exp：jwt的过期时间，这个过期时间必须要大于签发时间
                //.withExpiresAt()
                //其他自定义通信信息
                .withClaim("username", userEntity.getUsername())
                .withClaim("age",userEntity.getAge())
                .withExpiresAt(date)
                .sign(algorithm);
    }
}

执行打印

14:50:25.610 [main] INFO com.demo.security.util.JwtUtilTest -- token获取成功:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJ3ZWItZGVtbyIsImlzcyI6Ind0eXkiLCJleHAiOjE3MjEzNzM2MjUsImFnZSI6MTgsInVzZXJuYW1lIjoienMifQ.9dEWE3Q6zBa6szo1QVv5UaGfeXMsWyCJ64RSnWFx1Ns
14:50:25.624 [main] INFO com.demo.security.util.JwtUtilTest -- token长度:179
14:50:25.645 [main] INFO com.demo.security.util.JwtUtilTest -- 解析成功

 通过在线解析

这里为了证明第二步verify的重要性，改下代码：

public static void main(String[] args) {
        //1、生成token
        String username = "zs";
        Integer age = 18;
        String key = "123456";
        Algorithm algorithm = Algorithm.HMAC256(key);
        UserEntity userEntity = UserEntity.builder()
                .username(username)
                .age(age)
                .build();
        String token = getToken(userEntity,algorithm);
        log.info("token获取成功:{}",token);
        log.info("token长度:{}",token.length());
        //2、验证token，因为只要token是jwt，第三步一定会成功，这里是为了验证是不是我生成的，防止攻击
        try{
            Algorithm errorAlgorithm = Algorithm.HMAC256(key+"error");
            JWTVerifier verifier = JWT.require(errorAlgorithm).build();
            verifier.verify(token);
        }catch (Exception e){
            //throw异常
            log.error("验证失败");
        }
        //3、解析token
        UserEntity tokenUser = getUser(token);
        if(username.equals(tokenUser.getUsername())){
            log.info("解析成功，name={}",tokenUser.getUsername());
        }
    }

 打印：

15:48:42.922 [main] INFO com.demo.security.util.JwtUtilTest -- token获取成功:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJ3ZWItZGVtbyIsImlzcyI6Ind0eXkiLCJleHAiOjE3MjEzNzcxMjIsImFnZSI6MTgsInVzZXJuYW1lIjoienMifQ.mVQ5cO-nPo1SSw0qhXFdDbjQK4WdKSLmLjFWSkt8fQQ
15:48:42.924 [main] INFO com.demo.security.util.JwtUtilTest -- token长度:179
15:48:42.943 [main] ERROR com.demo.security.util.JwtUtilTest -- 验证失败
15:48:42.944 [main] INFO com.demo.security.util.JwtUtilTest -- 解析成功，name=zs
2、HS384
2.1、介绍

使用SHA-384算法进行HMAC签名。

2.2、demo

上面的代码修改为

Algorithm algorithm = Algorithm.HMAC384(secret);

执行打印

14:55:46.167 [main] INFO com.demo.security.util.JwtUtilTest -- token获取成功:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzM4NCJ9.eyJhdWQiOiJ3ZWItZGVtbyIsImlzcyI6Ind0eXkiLCJleHAiOjE3MjEzNzM5NDYsImFnZSI6MTgsInVzZXJuYW1lIjoienMifQ.wB0LaglQH_IcFKHa7oLm5r2Gof2DzCS0XmhvYC0m9q5nk4T4-CCTCpGllyc3waPR
14:55:46.167 [main] INFO com.demo.security.util.JwtUtilTest -- token长度:200
14:55:46.183 [main] INFO com.demo.security.util.JwtUtilTest -- 解析成功

3、HS512
3.1、介绍

使用SHA-512算法进行HMAC签名。

3.2、demo

上面的代码修改为

Algorithm algorithm = Algorithm.HMAC512(secret);

执行输出：

14:57:29.979 [main] INFO com.demo.security.util.JwtUtilTest -- token获取成功:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9.eyJhdWQiOiJ3ZWItZGVtbyIsImlzcyI6Ind0eXkiLCJleHAiOjE3MjEzNzQwNDksImFnZSI6MTgsInVzZXJuYW1lIjoienMifQ.J7-tJFmjP6Pnh9djMI6MnAEIFKK0Vvzn-ASVFRTWUf3kHa-NDOmYydP4jRDitui2EJNfxLu4taOo5YWZXYJoSQ
14:57:29.979 [main] INFO com.demo.security.util.JwtUtilTest -- token长度:222
14:57:29.994 [main] INFO com.demo.security.util.JwtUtilTest -- 解析成功

二、RSA算法（Rivest–Shamir–Adleman）

1、RS256
1.1、介绍

使用RSA和SHA-256算法进行签名。

1.2、demo

上面的代码修改为：

package com.demo.security.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.demo.security.constant.UserConstants;
import com.demo.security.entity.UserEntity;
import lombok.extern.slf4j.Slf4j;

import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.Date;
import java.util.Map;
@Slf4j
public class JwtUtilTest {

    public static void main(String[] args) throws Exception {
        //1、先生成公钥私钥
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(2048);
        KeyPair pair = keyGen.generateKeyPair();
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) pair.getPrivate();
        RSAPublicKey rsaPublicKey = (RSAPublicKey) pair.getPublic();
        //2、根据私钥生成jwt
        String username = "zs";
        Integer age = 18;
        UserEntity userEntity = UserEntity.builder()
                .username(username)
                .age(age)
                .build();
        String token = getToken(userEntity,rsaPrivateKey,rsaPublicKey);
        log.info("token获取成功:{}",token);
        log.info("token长度:{}",token.length());
        //3、先验证是否合法，注意第四步是一定可以成功的，这里是为了安全验证，校验token是不是我生成的，防止攻击
        Algorithm algorithm = Algorithm.RSA256(rsaPublicKey, null);
        JWTVerifier verifier = JWT.require(algorithm).build();
        //公钥验证不通过会抛异常
        verifier.verify(token);
        //log.info("验证成功");
        //4、根据公钥解析jwt
        UserEntity tokenUser = getUser(token);
        if(username.equals(tokenUser.getUsername())){
            log.info("解析成功");
        }
    }

    public static UserEntity getUser( String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            Map<String, Claim> claims = jwt.getClaims();
            String username = claims.get("username").asString();
            int age = claims.get("age").asInt();
            return UserEntity.builder()
                    .username(username)
                    .age(age)
                    .build();
        } catch (JWTDecodeException e) {
            return null;
        }
    }

    /**
     * 生成签名,5min(分钟)后过期
     * @param rsaPrivateKey
     * @param rsaPublicKey
     * @return 加密的token
     */
    public static String getToken(UserEntity userEntity, RSAPrivateKey rsaPrivateKey, RSAPublicKey rsaPublicKey) throws Exception {
        Date date = new Date(System.currentTimeMillis() + UserConstants.EXPIRE_TIME);
        Algorithm algorithm = Algorithm.RSA256(rsaPublicKey,rsaPrivateKey);
        // 附带username信息
        return JWT.create()
                //iss：签发方
                .withIssuer("wtyy")
                //aud：接收jwt的一方
                .withAudience("web-demo")
                //exp：jwt的过期时间，这个过期时间必须要大于签发时间
                //.withExpiresAt()
                //其他自定义通信信息
                .withClaim("username", userEntity.getUsername())
                .withClaim("age",userEntity.getAge())
                .withExpiresAt(date)
                .sign(algorithm);
    }

    private static RSAPublicKey convertStringToRSAPublicKey(String publicKeyString) throws Exception {
        publicKeyString = publicKeyString.replaceAll("\\n", "")
                .replace("-----BEGIN PUBLIC KEY-----", "")
                .replace("-----END PUBLIC KEY-----", "");

        // base64 decode
        byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyString);

        // X509EncodedKeySpec change to PublicKey
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);

        // change PublicKey to RSAPublicKey
        return (RSAPublicKey) publicKey;
    }
}

执行打印

15:39:47.174 [main] INFO com.demo.security.util.JwtUtilTest -- token获取成功:eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJhdWQiOiJ3ZWItZGVtbyIsImlzcyI6Ind0eXkiLCJleHAiOjE3MjEzNzY1ODcsImFnZSI6MTgsInVzZXJuYW1lIjoienMifQ.ERWm_kHMzFyEnrgaRC1TX19tmdalidKZ3h-SSrRkMuMmvYghFSsKWkIpvrhcXN-vtigweUThjg7IbHvS8unWV11Z6eb8vHldlq6kXnrTl802oEQqr6ORRnMafmxqEX7KqQsv7vv0JDwLbf8xEM4gebJqU_fKBOtw5mKivKt2fmZXs4vrBFHU_OXex4cUZp1TdMEAhJeysRhFGcLHqctgTkqx7NIUj80cODTMPfv2HNUJu-nZ5vn5oCmOkhD9yB5A3lpc7DM_qDL57jRQazoQMyTg97P9p_5x5qzI4mQNEqlnJyhJ9U-sqVsyFka_JiehyHJn_CEtpR031MFw0mUd-g
15:39:47.176 [main] INFO com.demo.security.util.JwtUtilTest -- token长度:478
15:39:47.199 [main] INFO com.demo.security.util.JwtUtilTest -- 解析成功

 为了验证第三步的重要性，改下代码：

    //3、先验证是否合法，注意第四步是一定可以成功的，这里是为了安全验证，校验token是不是我生成的，防止攻击
        try{
            Algorithm algorithm = Algorithm.RSA256(null, null);
            JWTVerifier verifier = JWT.require(algorithm).build();
            //公钥验证不通过会抛异常
            verifier.verify(token);
        }catch (Exception e){
            log.error("验证失败");
        }
        //4、根据公钥解析jwt
        UserEntity tokenUser = getUser(token);
        if(username.equals(tokenUser.getUsername())){
            log.info("解析成功,name={}",tokenUser.getUsername());
        }


这两步打印：
15:42:19.882 [main] ERROR com.demo.security.util.JwtUtilTest -- 验证失败
15:42:19.905 [main] INFO com.demo.security.util.JwtUtilTest -- 解析成功,name=zs
2、RS384

使用RSA和SHA-384算法进行签名。

上面的代码修改下，256改成384，执行下输出

15:51:33.549 [main] INFO com.demo.security.util.JwtUtilTest -- token获取成功:eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzM4NCJ9.eyJhdWQiOiJ3ZWItZGVtbyIsImlzcyI6Ind0eXkiLCJleHAiOjE3MjEzNzcyOTMsImFnZSI6MTgsInVzZXJuYW1lIjoienMifQ.lWIWB72Xnm3Gxdoa6TTM2g7SrgDY3m3sn1TShQPJrpyXm_Z9pnv9qup3yAvUmGyR2HbsqsjX9mG6kMz5A3Rxuvl2icIA0TzSq3SD4X0CWg6yOa1CO76W9yEHvFewPkYNfDNx1gHwcmyLW4PavcZaOnpMrOfILaVoqUeoaJ9d5fye39ASLbsgj76JL1KdX7EaM3eb_x3DPp7zt46rsV76z5IGlXnxAch4va5zF3h73Pj6HmbQ6g9FDCPa9Kz3Yd9PlxKm9lWTDMTNrEZ0Dphgi7mxs2XLJoYIfJEY9_jqLeFkl2otFLTAURoS_sNrOvQMtXRkDPoraIi5gfM-IyUnJA
15:51:33.551 [main] INFO com.demo.security.util.JwtUtilTest -- token长度:478
15:51:33.573 [main] INFO com.demo.security.util.JwtUtilTest -- 解析成功
3、RS512

使用RSA和SHA-512算法进行签名。

上面的代码修改下，384改成512，执行下输出：

15:52:24.816 [main] INFO com.demo.security.util.JwtUtilTest -- token获取成功:eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzUxMiJ9.eyJhdWQiOiJ3ZWItZGVtbyIsImlzcyI6Ind0eXkiLCJleHAiOjE3MjEzNzczNDQsImFnZSI6MTgsInVzZXJuYW1lIjoienMifQ.sC5D9qDnJg4fvtg3M9MSlJqZ2K7t88yFaP4-KWLyd5Y5Tm-PlwJImLtT3g2NwW-NGnmUpVZ0nYY47io49FN7IYKRv7NxpniAwWOc-JBJM1o2SeGAsG_dPBfdOxB4_6f1V5gMiDuqHIdyjW7DPl3w72j2-etjXg4xBG0ed-LihzZ7MWhWreEoPoBSJja8CDalE0bXAAHQn3EKvlbAlTO7QLdOpJvM1cQJlBMTzaes8sXbc-yqY-lQ7LOtKbqdd90d_muBUq5Qn4bjO5GWcq-QGTjzSXvQH-ttKJliVblvJYpCMs0mAFIniL41lKTNNVg3G-zRcFJtwtdOUSYMEadEIA
15:52:24.818 [main] INFO com.demo.security.util.JwtUtilTest -- token长度:478
15:52:24.839 [main] INFO com.demo.security.util.JwtUtilTest -- 解析成功

三、ECDSA算法（Elliptic Curve Digital Signature Algorithm）：

特点：与RSA算法类似，ECDSA也是非对称加密算法，但使用的是椭圆曲线加密，通常比RSA算法更快，签名和验证过程更高效。同时，ECDSA的密钥长度较短，有助于减少Token的大小。

1、ES256

使用椭圆曲线加密算法ECDSA和SHA-256进行签名。

demo：

package com.demo.security.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.demo.security.constant.UserConstants;
import com.demo.security.entity.UserEntity;
import lombok.extern.slf4j.Slf4j;

import java.security.*;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.ECGenParameterSpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.Date;
import java.util.Map;
@Slf4j
public class JwtUtilTest {

    public static void main(String[] args) throws Exception {
        //1、先生成公钥私钥
        // 初始化KeyPairGenerator
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");
        // 设置ECDSA使用的椭圆曲线为secp256r1
        ECGenParameterSpec ecSpec = new ECGenParameterSpec("secp256r1");
        keyPairGenerator.initialize(ecSpec);
        KeyPair pair = keyPairGenerator.generateKeyPair();
        ECPrivateKey ecPrivateKey = (ECPrivateKey) pair.getPrivate();
        ECPublicKey ecPublicKey = (ECPublicKey) pair.getPublic();
        //2、根据私钥生成jwt
        String username = "zs";
        Integer age = 18;
        UserEntity userEntity = UserEntity.builder()
                .username(username)
                .age(age)
                .build();
        String token = getToken(userEntity,ecPrivateKey,ecPublicKey);
        log.info("token获取成功:{}",token);
        log.info("token长度:{}",token.length());
        //3、先验证是否合法，注意第四步是一定可以成功的，这里是为了安全验证，校验token是不是我生成的，防止攻击
        Algorithm algorithm = Algorithm.ECDSA256(ecPublicKey, null);
        JWTVerifier verifier = JWT.require(algorithm).build();
        //公钥验证不通过会抛异常
        verifier.verify(token);
        log.info("验证成功");
        //4、根据公钥解析jwt
        UserEntity tokenUser = getUser(token);
        if(username.equals(tokenUser.getUsername())){
            log.info("解析成功");
        }
    }

    public static UserEntity getUser( String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            Map<String, Claim> claims = jwt.getClaims();
            String username = claims.get("username").asString();
            int age = claims.get("age").asInt();
            return UserEntity.builder()
                    .username(username)
                    .age(age)
                    .build();
        } catch (JWTDecodeException e) {
            return null;
        }
    }

    /**
     * 生成签名,5min(分钟)后过期
     * @param rsaPrivateKey
     * @param rsaPublicKey
     * @return 加密的token
     */
    public static String getToken(UserEntity userEntity, ECPrivateKey rsaPrivateKey, ECPublicKey rsaPublicKey) throws Exception {
        Date date = new Date(System.currentTimeMillis() + UserConstants.EXPIRE_TIME);
        Algorithm algorithm = Algorithm.ECDSA256(rsaPublicKey,rsaPrivateKey);
        // 附带username信息
        return JWT.create()
                //iss：签发方
                .withIssuer("wtyy")
                //aud：接收jwt的一方
                .withAudience("web-demo")
                //exp：jwt的过期时间，这个过期时间必须要大于签发时间
                //.withExpiresAt()
                //其他自定义通信信息
                .withClaim("username", userEntity.getUsername())
                .withClaim("age",userEntity.getAge())
                .withExpiresAt(date)
                .sign(algorithm);
    }
}

执行输出：

16:00:37.510 [main] INFO com.demo.security.util.JwtUtilTest -- token获取成功:eyJ0eXAiOiJKV1QiLCJhbGciOiJFUzI1NiJ9.eyJhdWQiOiJ3ZWItZGVtbyIsImlzcyI6Ind0eXkiLCJleHAiOjE3MjEzNzc4MzcsImFnZSI6MTgsInVzZXJuYW1lIjoienMifQ.niLzXGc3kuiYm75UrbCtK9qUTdDIUyo89nLkb1tOyH1dE--G_IILabMFsOlYHgTdx-z_zoJFjHqtlaIYXXdD8w
16:00:37.512 [main] INFO com.demo.security.util.JwtUtilTest -- token长度:222
16:00:37.538 [main] INFO com.demo.security.util.JwtUtilTest -- 验证成功
16:00:37.540 [main] INFO com.demo.security.util.JwtUtilTest -- 解析成功

 通过在线解析：

2、ES384

使用ECDSA和SHA-384进行签名。

3、ES512

使用ECDSA和SHA-512进行签名。

w_t_y_y
关注
专栏目录
JWT加密算法原理及实现
AI天才研究院
10-03 1186
作者：禅与计算机程序设计艺术 1.简介 JSON Web Token（JWT）是一个开放标准（RFC7519），它定义了一种紧凑且自包含的方式，用于在各方之间安全地传输信息。该规范允许用户将登录 credentials 和 session state 作为 JSON 对象进行加密，这些信息可以被验证但无
jwt常见的加密算法
smarthome_man的博客
02-11 7722
JWT：是客户端和服务器进行数据安全传输的一种标准 JWT的组成是由头，负载，签名组成 头：指定的签名的加密算法方式 负载：自定义信息内容 签名：头部Base64通过加密算法和密钥生成的 作用：防止令牌信息被篡改 JWT令牌优点： 1、jwt基于json，非常方便解析 2、可以在令牌中自定义丰富的内容，易扩展； 3、通过非对称加密算法及数字签名技术。 常见的加密算法： 加密算法的种类： 1、可逆加密算法 加密后，密文可以解密得到原文 一般用于签名和认证。私钥服务器保存, 用来加密, 公钥客户拿着用于对于令牌
JWT算法
weixin_45408840的博客
11-08 1327
1、定义：JWT（Json Web Token）是现在流行的一种对 Restful 接口进行验证的机制的基础 2、JWT 的 特点： 2.1、把用户信息放到一个 JWT 字符串中，用户信息部分是明文的，再加上一部分签名区 域，签名部分是服务器对于“明文部分+秘钥”加密的，这个加密信息只有服务器端才能解 析。 2.2、用户端只是存储、转发这个 JWT 字符串。如果客户端篡改了明文部分，那么服务...
Jwt 加密 解密 公钥 私钥
yangkecheng2021的博客
08-27 264
jwt的创建和解析，公钥私钥的生成
JWT加密解密算法
qq_35531985的博客
04-30 7462
JWT(JSON Web Token)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它将使用数字签名（密钥）记性加密解密。 什么时候使用JWT Authorization (授权) : 这是JWT最常见的使用场景，一旦用户登录后，后面每个请求都将包含JWT，用户将被允许访问该令牌允许的路由、服务和资源。单点登录是JWT应用的一个场景，并且JWT可以轻松的跨域使用。 Information Exchange (
JWT加密详解
qq_37647812的博客
10-07 4070
JWT采用的加密方式是非常安全的，我们可以使用JWT的payload部分加密来进行鉴权，并且这种方式相对于传统的cookie与session认证方式更为安全。HS256使用HMAC 算法，RS256使用RSA 证书，且输入的 jwk 和 x5c 可以使用不同的公钥证书。2、CSRF攻击，攻击者可以通过伪造一个请求，再把假的JWT传过去，这时后台就会认为该用户已经登录，攻击者就可以做一些非法的事情。2、无状态：JWT本身是无状态的，每个请求的Token都是独立的，减少了Server的开销。
Token和JWT和加密算法
最新发布
weixin_45459648的博客
09-08 941
通常直接使用HMAC SHA256（对称加密算法），并且支持多种算法HMAC 是密钥相关的 哈希运算消息认证码（Hash-based Message Authentication Code），HMAC 运算利用 哈希算法 (MD5、SHA1 等)，以 一个密钥 和 一个消息 为输入，生成一个 消息摘要 作为 输出。HMAC 发送方 和 接收方 都有的 key 进行计算，而没有这把 key 的第三方，则是 无法计算 出正确的 散列值的，这样就可以 防止数据被篡改。数据摘。
jwt及加密算法
Leon_Jinhai_Sun的博客
02-10 7847
JWT 简介 JWT，全称是Json Web Token， 是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权；官网：https://jwt.io GitHub上jwt的java客户端：https://github.com/jwtk/jjwt 数据格式 JWT包含三部分数据： Header：头部，通常头部有两部分信息： 声明类型，这里...
JWT(json web token加密算法) for C# dll 文件，亲测可用
07-02
2. **JWT创建与验证流程**： - 创建JWT：使用指定的算法，结合私钥（或秘钥）生成签名，将头部、负载和签名组合成一个完整的JWT字符串。 - 验证JWT：接收方使用公钥（或秘钥）和同样的算法，检查签名是否与头部和...
JWT 网关TOKEN 加密
05-15
因此，AES成为优于DES的加密算法，更适合用来加密JWT令牌。 总的来说，为了增强JWT网关TOKEN的安全性，我们可以采用AES算法对JWT进行加密。通过设置足够长的密钥，可以有效防止非法破解，同时AES的高效性能确保了在...
Oauth2+JWT 加密token
技术札记
07-08 9429
JWT 对称加密 JWT将 相关信息放在 令牌里 jwt全称 JSON Web Token。这个实现方式不用管如何进行存储（内存或磁盘）， 因为它可以把相关信息数据编码存放在令牌里 。JwtTokenStore 不会保存任何数据， 但是它在转换令牌值以及授权信息方面与 DefaultTokenServices 所扮演的角色是一样的。 安全性 OAuth2提供了JwtAccessTokenCo.........
JWT详解
热门推荐
baobao的博客
07-07 27万+
本文从本人博客搬运，原文格式更加美观，可以移步原文阅读：JWT详解 JWT简介 1.什么是JWT 在介绍JWT之前，我们先来回顾一下利用token进行用户身份验证的流程： 客户端使用用户名和密码请求登录 服务端收到请求，验证用户名和密码 验证成功后，服务端会签发一个token，再把这个token返回给客户端 客户端收到token后可以把它存储起来，比如放到cookie中 客户端每次向服务端请求资源时需要携带服务端签发的token，可以在cookie或者header中携带 服务端收到请求，然后去验证客户端请
18.jwt加密
qq_22225239的博客
08-12 197
18.jwt加密 jwt 官网https://jwt.io/ jwt:json web token jwt-simple： https://www.npmjs.com/package/jwt-simple jsonwebtoken：https://www.npmjs.com/package/jsonwebtoken express-jwt ： https://www.npmjs.com/...
JWT 算法
weixin_44481764的博客
11-09 1479
一、 JWT 简介 JWT（Json Web Token）是现在流行的一种对 Restful 接口进行验证的机制的基础。 JWT 的 特点：把用户信息放到一个 JWT 字符串中，用户信息部分是明文的，再加上一部分签名区 域，签名部分是服务器对于“明文部分+秘钥”加密的，这个加密信息只有服务器端才能解 析。 用户端只是存储、转发这个 JWT 字符串。如果客户端篡改了明文部分，那么服务器端 解密...
jwt加密
ChengChengxn的博客
06-03 998
jwt加密 1.pom <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version> </dependency> <dependency> <groupId>com.auth0</groupId> <ar
JWT 加密
moty2011的博客
05-06 786
package com.mes.metering.util; import com.auth0.jwt.JWT; import com.auth0.jwt.JWTVerifier; import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.interfaces.DecodedJWT; import java.util.Date; import java.util.HashMap; import java.util.Map; /**.
JWT加密规则
weixin_44949531的博客
07-16 1689
JWT加密规则 JWT（Java Web Token）是基于token的身份认证的方案,可以保证安全传输的前提下传送一些基本的信息,JWT的安全特性保证了token的不可伪造和不可篡改。本质上是一个独立的身份验证令牌，可以包含用户标识、用户角色和权限等信息，以及您可以存储任何其他信息（自包含）。任何人都可以轻松读取和解析，并使用密钥来验证真实性。JWT包含如下三部分： 头部（header）: {“alg”:“HS256”} , 使用base64编码 载荷（playload）: {“jti”:“18cba4
JWT的加密解密
weixin_53520295的博客
06-13 2185
JWT的加密解密
【网络安全 | 密码学】JWT基础知识及攻击方式详析
等风来
04-17 1291
JWT（Json Web Token）是一种用于在网络应用之间安全地传输信息的开放标准。它通过将用户信息以JSON格式加密并封装在一个token中，然后将该token发送给服务端进行验证，从而实现身份验证和授权。
php实现jwt的rs256加密算法
05-25
实现JWT的RS256加密算法需要使用PHP的openssl扩展，以下是一个简单的示例代码： ```php <?php // 生成JWT Token function generateToken($payload, $privateKey) { // JWT 头部 $header = array( "alg" => "RS256", "typ" => "JWT" ); // JWT 载荷 $payload = json_encode($payload); // JWT 签名 $headerEncoded = base64UrlEncode(json_encode($header)); $payloadEncoded = base64UrlEncode($payload); $data = $headerEncoded . '.' . $payloadEncoded; $signature = ''; openssl_sign($data, $signature, $privateKey, OPENSSL_ALGO_SHA256); $signatureEncoded = base64UrlEncode($signature); // JWT Token $jwtToken = $headerEncoded . '.' . $payloadEncoded . '.' . $signatureEncoded; return $jwtToken; } // 验证JWT Token function verifyToken($jwtToken, $publicKey) { $jwtParts = explode('.', $jwtToken); if (count($jwtParts) != 3) { return false; } $headerEncoded = $jwtParts[0]; $payloadEncoded = $jwtParts[1]; $signatureEncoded = $jwtParts[2]; $header = json_decode(base64UrlDecode($headerEncoded), true); if (!isset($header['alg']) || $header['alg'] !== 'RS256') { return false; } $payload = json_decode(base64UrlDecode($payloadEncoded), true); if (!$payload) { return false; } $data = $headerEncoded . '.' . $payloadEncoded; $signature = base64UrlDecode($signatureEncoded); // 验证签名 $verifyResult = openssl_verify($data, $signature, $publicKey, OPENSSL_ALGO_SHA256); if ($verifyResult === 1) { return true; } else { return false; } } // Base64 URL 编码 function base64UrlEncode($data) { $urlsafe = strtr(base64_encode($data), '+/', '-_'); return rtrim($urlsafe, '='); } // Base64 URL 解码 function base64UrlDecode($data) { $data = strtr($data, '-_', '+/'); $dataLen = strlen($data) % 4; if ($dataLen) { $data .= str_repeat('=', 4 - $dataLen); } return base64_decode($data); } // 读取私钥 $privateKey = openssl_pkey_get_private("file://path/to/private_key.pem"); // 读取公钥 $publicKey = openssl_pkey_get_public("file://path/to/public_key.pem"); // 生成Token $payload = array( "sub" => "1234567890", "name" => "John Doe", "iat" => 1516239022 ); $jwtToken = generateToken($payload, $privateKey); echo "JWT Token: " . $jwtToken . "\n"; // 验证Token $verifyResult = verifyToken($jwtToken, $publicKey); if ($verifyResult) { echo "Token 验证成功\n"; } else { echo "Token 验证失败\n"; } ``` 在以上示例代码中，`generateToken` 函数用于生成JWT Token，`verifyToken` 函数用于验证JWT Token。`base64UrlEncode` 和 `base64UrlDecode` 分别用于进行Base64 URL编码和解码。请注意，需要将私钥和公钥保存在文件中，并且需要指定正确的文件路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

w_t_y_y

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值