jwt衍生出的问题结合实例

1.JWT简介

JWT是JSON Web Token的缩写，是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准((RFC 7519)。JWT本身没有定义任何技术实现，它只是定义了一种基于Token的会话管理的规则，涵盖Token需要包含的标准内容和Token的生成过程，特别适用于分布式站点的单点登录(SSO) 场景。（相对于cookie无法跨域问题）

相比较与传统的Session登录方式的：
在介绍JWT之前，我们先来回顾一下利用token进行用户身份验证的流程：

• 客户端使用用户名和密码请求登录
• 服务端收到请求，验证用户名和密码
• 验证成功后，服务端会签发一个token，再把这个token返回给客户端
• 客户端收到token后可以把它存储起来，比如放到cookie中
• 客户端每次向服务端请求资源时需要携带服务端签发的token，可以在cookie或者header中携带
• 服务端收到请求，然后去验证客户端请求里面带着的token，如果验证成功，就向客户端返回请求数据

这种基于token的认证方式相比传统的session认证方式更节约服务器资源，并且对移动端和分布式更加友好。其优点如下：

• 支持跨域访问：cookie是无法跨域的，而token由于没有用到cookie(前提是将token放到请求头中)，所以跨域后不会存在信息丢失问题
• 无状态：token机制在服务端不需要存储session信息，因为token自身包含了所有登录用户的信息，所以可以减轻服务端压力
• 更适用CDN：可以通过内容分发网络请求服务端的所有资料
• 更适用于移动端：当客户端是非浏览器平台时，cookie是不被支持的，此时采用token认证方式会简单很多
• 无需考虑CSRF：由于不再依赖cookie，所以采用token认证方式不会发生CSRF，所以也就无需考虑CSRF的防御

通俗地说，JWT的本质就是一个字符串，它是将用户信息保存到一个Json字符串中，然后进行编码后得到一个JWT token，并且这个JWT token带有签名信息，接收后可以校验是否被篡改，所以可以用于在各方之间安全地将信息作为Json对象传输。JWT的认证流程如下：

• 首先，前端通过Web表单将自己的用户名和密码发送到后端的接口，这个过程一般是一个POST请求。建议的方式是通过SSL加密的传输(HTTPS)
• 后端核对用户名和密码成功后，将包含用户信息的数据作为JWT的Payload，将其与JWT Header分别进行Base64编码拼接后签名，形成一个JWT Token，形成的JWT Token就是一个如同lll.zzz.xxx的字符串
• 后端将JWT Token字符串作为登录成功的结果返回给前端。前端可以将返回的结果保存在浏览器中，退出登录时删除保存的JWT Token即可
• 前端在每次请求时将JWT Token放入HTTP请求头中的Authorization属性中(解决XSS和XSRF问题)
• 后端检查前端传过来的JWT Token，验证其有效性，比如检查签名是否正确、是否过期、token的接收方是否是自己等等
• 验证通过后，后端解析出JWT Token中包含的用户信息，进行其他逻辑操作(一般是根据用户信息得到权限等)，返回结果
  

2.JWT的结构

JWT由3部分组成：标头(Header)、有效载荷(Payload)和签名(Signature)。在传输的时候，会将JWT的3部分分别进行Base64编码后用.进行连接形成最终传输的字符串

• 头部（Header）
• 负载（Payload）
• 签名（Signature）

头部和负载以json形式存在，这就是JWT中的JSON,三部分的内容都分别单独经过了Base64编码，以.拼接成一个JWT Token。
Header
**JWT头**是一个描述JWT元数据的JSON对象，alg属性表示签名使用的算法，默认为HMAC SHA256（写为HS256）；typ属性表示令牌的类型，JWT令牌统一写为JWT。最后，使用Base64 URL算法将上述JSON对象转换为字符串保存

{
   "alg" : "HS256",
   "typ" : "JWT"
}

Payload
Payload表示负载，也是一个JSON对象，JWT规定了7个官方字段供选用
JWT默认是不加密的，因为只是采用base64算法,任何人都可以读到，所以不要把秘密信息放在这里

iss (issuer) : 签发人
exp (expiration time) : 过期时间
sub (subject) : 主题
aud (audience) : 受众
nbf (Not Before) : 生效时间
iat (Issued At) : 签发时间
jti (JWT ID) : 编号

Signature
Signature部分是对前两部分的签名，防止数据篡改。
首先，需要指定一一个密钥(secret) 。 这个密钥只有服务器才知道，不能泄露给用户。然后，使用Header里面指定的签名算法(默认是HMAC SHA256)，按照下面的公式产生签名。

HMAXSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload),secret)

3.JWT加密

其实JWT(JSON Web Token)指的是一种规范，这种规范允许我们使用JWT在两个组织之间传递安全可靠的信息，JWT的具体实现可以分为以下几种：

    nonsecure JWT：未经过签名，不安全的JWT
    JWS：经过签名的JWT
    JWE：payload部分经过加密的JWT

1.nonsecure JWT

未经过签名，不安全的JWT。其header部分没有指定签名算法

{
  "alg": "none",
  "typ": "JWT"
}

并且也没有Signature部分
2.JWS

JWS ，也就是JWT Signature，其结构就是在之前nonsecure JWT的基础上，在头部声明签名算法，并在最后添加上签名。创建签名，是保证jwt不能被他人随意篡改。我们通常使用的JWT一般都是JWS

为了完成签名，除了用到header信息和payload信息外，还需要算法的密钥，也就是secretKey。加密的算法一般有2类：

• 对称加密：secretKey指加密密钥，可以生成签名与验签
• 非对称加密：secretKey指私钥，只用来生成签名，不能用来验签(验签用的是公钥)

JWT的密钥或者密钥对，一般统一称为JSON Web Key，也就是JWK

到目前为止，jwt的签名算法有三种：

• HMAC【哈希消息验证码(对称)】：HS256/HS384/HS512
• RSASSA【RSA签名算法(非对称)】（RS256/RS384/RS512）
• ECDSA【椭圆曲线数据签名算法(非对称)】（ES256/ES384/ES512）

java-jwt的对称签名
pom依赖

 <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.7.0</version>
        </dependency>
</dependency>

JWT对称加密解密

public class JWTTest {
    @Test
    public void testGenerateToken() {
        // 指定token过期时间为10秒
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND, 100);

        String token = JWT.create()
                .withHeader(new HashMap<>())  // Header
                .withClaim("admin", 123456)  // Payload
                .withClaim("root", "123456")
                .withExpiresAt(calendar.getTime())  // 过期时间
                .sign(Algorithm.HMAC256("root"));  // 签名用的secret

        System.out.println(token);
    }

    @Test
    public void testResolveToken() {
        // 创建解析对象，使用的算法和secret要与创建token时保持一致
        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("secret")).build();
        // 解析指定的token
        DecodedJWT decodedJWT = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6ImJhb2JhbyIsImV4cCI6MTY1Mjk0NTkwNSwidXNlcklkIjoyMX0.tOFA_ksOU31al495GWWSGvJD0eheWy27DF59Hj8WGeQ");
        // 获取解析后的token中的payload信息
        Claim userId = decodedJWT.getClaim("admin");
        Claim userName = decodedJWT.getClaim("root");
        System.out.println(userId.asInt());
        System.out.println(userName.asString());
        // 输出超时时间
        System.out.println(decodedJWT.getExpiresAt());
    }
}

装成工具类

public class JWTUtils {
    // 签名密钥
    private static final String SECRET = "!DAR$";

    /**
     * 生成token
     * @param payload token携带的信息
     * @return token字符串
     */
    public static String getToken(Map<String,String> payload){
        // 指定token过期时间为7天
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE, 7);

        JWTCreator.Builder builder = JWT.create();
        // 构建payload
        payload.forEach((k,v) -> builder.withClaim(k,v));
        // 指定过期时间和签名算法
        String token = builder.withExpiresAt(calendar.getTime()).sign(Algorithm.HMAC256(SECRET));
        return token;
    }


    /**
     * 解析token
     * @param token token字符串
     * @return 解析后的token
     */
    public static DecodedJWT decode(String token){
        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(SECRET)).build();
        DecodedJWT decodedJWT = jwtVerifier.verify(token);
        return decodedJWT;
    }
}

非对称签名
生成jwt串的时候需要指定私钥，解析jwt串的时候需要指定公钥
非对称加密算法实现机密信息交换的基本过程是：
甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开；得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方；甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。甲方只能用其专用密钥解密由其公用密钥加密后的任何信息。
公钥和私钥的生成

    @Autowired
    private RedisUtil redisUtil;

    @Value("${param.jwt.overtime:1}")
    private Integer overTime;


    /**
     * @description: 获取jwt密钥 公钥 保存到redis 每隔1DAY更新一次
     * @author hdh
     * @date: 2022/5/27 16:28
     * @param:
     * @return: Map<String, String>
     */
    public String getJwtKey() {

        String publicKeyStr = null;
        String privateKeyStr = null;
        try {

            Boolean isPublicKey = redisUtil.hasKey(SysConsts.RedisCode.PUBLIC_KEY);
            Boolean isPrivateKey = redisUtil.hasKey(SysConsts.RedisCode.PRIVATE_KEY);
            if (isPublicKey && isPrivateKey) {
                publicKeyStr = String.valueOf(redisUtil.get(SysConsts.RedisCode.PUBLIC_KEY));

            } else {
                // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
                KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
                // 初始化密钥对生成器，密钥大小为96-2048位
                keyPairGen.initialize(2048, new SecureRandom());
                // 生成一个密钥对，保存在keyPair中
                KeyPair keyPair = keyPairGen.generateKeyPair();

                RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
                RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

                publicKeyStr = new String(Base64.encodeBase64(publicKey.getEncoded()));
                privateKeyStr = new String(Base64.encodeBase64((privateKey.getEncoded())));

                redisUtil.setEx(SysConsts.RedisCode.PUBLIC_KEY, publicKeyStr, overTime, TimeUnit.DAYS);
                redisUtil.setEx(SysConsts.RedisCode.PRIVATE_KEY, privateKeyStr, overTime, TimeUnit.DAYS);

            }

        } catch (NoSuchAlgorithmException e) {

            e.printStackTrace();
            throw new SysRuntimeException(SysConsts.JwtCode.JGENERATL_KEY_ERROR, SysConsts.JwtCode.JGENERATL_KEY_ERROR_MSG);

        }
        return publicKeyStr;

    }

基本逻辑：
比如发送者S要给接受者R传输报文信息，为了避免信息泄露，秘钥签发者R事先通过RSA加密算法生成秘钥对，并且将公钥事先给到S，私钥则自己保留，S向R传输信息时，先用R提供的公钥加密报文，然后再将报文传输给R，R获取加密后的信息，再通过其单独持有的私钥解密报文，即使报文被窃听，窃听者没有私钥，也无法解密。公钥对外公开的，私钥自己保留，由于公钥是公开的，任何人都能拿到（会同时给到多个人），都可以使用公钥来加密发送伪造内容，因此，验证发送者的身份，确保报文的安全性显得非常重要。
简述： 发送者公钥加密–>接收者私钥解密
加密

 /**
     * @description:RSA公钥加密
     * @author hdh
     * @date: 2022/5/27 16:28
     * @param: str加密字符串 publicKey 公钥
     * @return: String
     */
    public static String encrypt(String str, String publicKey) throws Exception {
        //base64编码的公钥
        byte[] decoded = Base64.decodeBase64(publicKey);
        RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
        //RSA加密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        String outStr = Base64.encodeBase64String(cipher.doFinal(str.getBytes("UTF-8")));
        return outStr;
    }

解密

 /**
     * @description:RSA私钥解密
     * @author hdh
     * @date: 2022/5/27 16:28
     * @param: str加密字符串 publicKey 私钥
     * @return: String
     */
    public static String decrypt(String str, String privateKey) throws Exception {
        //64位解码加密后的字符串
        byte[] inputByte = Base64.decodeBase64(str.getBytes("UTF-8"));
        //base64编码的私钥
        byte[] decoded = Base64.decodeBase64(privateKey);
        RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
        //RSA解密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, priKey);
        String outStr = new String(cipher.doFinal(inputByte));
        return outStr;
    }

4.JWT基于SpringBoot的简单登录(对称加密)

5.JWT和Spring Security之间的应用

6.上文中 base64的加密方式

7.Token过期刷新机制

<–参考博客–>
<–参考博客–>