SpringBoot-JWT

发表于 | 分类于 | 评论数： | 阅读次数：

一、什么是JSON Web Token？

JSON Web Token（JWT）是一个开放标准（RFC7519），它定义了一种紧凑且独立的方式，用于在各方之间作为JSON对象安全地传输信息。
此信息可以通过数字签名进行验证和信任。JWT可以使用秘密（使用HMAC算法）或使用RSA或ECDSA的公钥/私钥对进行签名。

二、JWT的使用场景主要包括：

  • 认证授权
    这是比较常见的使用场景，只要用户登录过一次系统，之后的请求都会包含签名出来的token，通过token也可以用来实现单点登录。
    因为它的开销很小，并且能够在不同的域中轻松使用。
  • 交换信息
    JSON Web令牌是在各方之间安全传输信息的好方法。因为JWT可以签名 - 例如，使用公钥/私钥对 - 您可以确定发件人是他们所说的人。此外，由于使用标头和有效负载计算签名，您还可以验证内容是否未被篡改。

三、JWT 的组成结构

实际的 jwt 产生的token，大概长得如下的格式

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.
eyJzdWIiOiJ0ZXN0IiwiYXVkIjpbImFwcCIsIndlYiJdLCJkYXRhIjoie1wiYWdlXCI6MjQsXCJzZXhcIjoxLFwidXNlcklkXCI6MSxcInVzZXJuYW1lXCI6XCLluIXlpKflj5RcIn0iLCJpc3MiOiJyc3R5cm8iLCJleHAiOjE1NTUzOTg5NjIsImlhdCI6MTU1NTM5ODg0Mn0.
N1PbxQ1okvw-q8TWiSX0uMx1z6QL6IEUBtOfcwP7-Mg

它是一个很长的字符串，中间用点（.）分隔成三个部分。

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

注意，JWT 内部是没有换行的，这里只是为了便于展示，将它写成了几行

1、Header（头部）

标头通常由两部分组成：令牌的类型，即JWT，以及正在使用的签名算法，例如HMAC SHA256或RSA。
例如：

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

然后，这个JSON被编码为Base64Url，形成JWT的第一部分。

2、Payload（负载）

令牌的第二部分是有效负载，其中包含声明。声明是关于实体（通常是用户）和其他数据的声明
这个部分一般就是我们需要存贮的数据都放在这里。
JWT 规定了7个官方字段，供选用。

iss (issuer)：发布者
sub (subject)：主题
iat (Issued At)：生成签名的时间
exp (expiration time)：签名过期时间
aud (audience)：观众，相当于接受者
nbf (Not Before)：生效时间
jti (JWT ID)：编号

当然，也可以自定义字段，例如下面的 data 字段 

{
  "sub": "test",
  "aud": [
    "app",
    "web"
  ],
  "nbf": 1555399851,
  "data": "{\"age\":24,\"sex\":1,\"userId\":1,\"username\":\"帅大叔\"}",
  "iss": "rstyro",
  "exp": 1555399971,
  "iat": 1555399851,
  "jti": "75f67651-4cc8-431a-9429-c15df52d5acd"
}

然后经过Base64Url编码，形成JSON Web令牌的第二部分

3、Signature（签名）

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

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

算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用”点”（.）分隔，就可以返回给用户。

4、Base64URL

前面提到，Header 和 Payload 串型化的算法是 Base64URL。这个算法跟 Base64 算法基本类似，但有一些小的不同。

JWT 作为一个令牌token，有些场合可能会放到 URL（比如 api.example.com/?token=xxx）。Base64 有三个字符+、/和=，在 URL 里面有特殊含义，所以要被替换掉：=被省略、+替换成-，/替换成_ 。这就是 Base64URL 算法

四、JWT 的特点

1、号外

就我现在所知道的，互联网服务中的用户认证方式 有两种：

  • SessionId
    比如，用户在浏览器中用户名密码登录成功之后，浏览器每次发请求都会自己带上sessionid 发送给服务器。服务器通过sessionID 得到用户信息
  • TOKEN
    token,一般在手机app 端比较常用的方式，那就是用户登录成功之后，服务器返回一个 授权的token 字符串，app 每次请求也要带着这个token 转到服务器，服务器通过 token 得到用户信息

如上两种方式都很类似，换汤不换药。它们的相同点就是：认证信息都保存在后端服务器
而JWT 和 它们的区别就是：认证信息保存在了客户端，减轻服务端的内存压力。

2、特点

  • JWT是无状态的，特别适用于分布式站点的单点登录（SSO）场景
  • JWT 不仅可以用于认证，也可以用于交换信息。有效使用 JWT，可以降低服务器查询数据库的次数。
  • 因为有签名，所以JWT可以防止被篡改
  • 由于JWT的payload是使用base64编码的，并没有加密，因此JWT中不能存储敏感数据。而session的信息是存在服务端的，相对来说更安全。
  • 由于是无状态使用JWT，所有的数据都被放到JWT里，如果还要进行一些数据交换，那载荷会很大，经过编码之后导致JWT非常长
  • JWT是一次性的。想修改里面的内容，就必须签发一个新的JWT
  • 一旦签发一个JWT，在到期之前就会始终有效，无法中途废弃。

五、JWT 的加密方式

JWT签名算法中，一般有两个选择，一个采用HS256,另外一个就是采用RS256。
签名实际上是一个加密的过程，生成一段标识（也是JWT的一部分）作为接收方验证信息是否被篡改的依据。
RS256 (采用SHA-256 的 RSA 签名) 是一种非对称算法, 它使用公共/私钥对: 标识提供方采用私钥生成签名, JWT 的使用方获取公钥以验证签名。由于公钥 (与私钥相比) 不需要保护, 因此大多数标识提供方使其易于使用方获取和使用 (通常通过一个元数据URL)。
另一方面, HS256 (带有 SHA-256 的 HMAC 是一种对称算法, 双方之间仅共享一个 密钥。由于使用相同的密钥生成签名和验证签名, 因此必须注意确保密钥不被泄密。
在开发应用的时候启用JWT，使用RS256更加安全，你可以控制谁能使用什么类型的密钥。另外，如果你无法控制客户端，无法做到密钥的完全保密，RS256会是个更佳的选择，JWT的使用方只需要知道公钥。
由于公钥通常可以从元数据URL节点获得，因此可以对客户端进行进行编程以自动检索公钥。如果采用这种方式，从服务器上直接下载公钥信息，可以有效的减少配置信息

六、JWT 代码实现

在官网:jwt.io中有各个语言的库可以使用,我用的是 auth0 的Java.
地址：https://github.com/auth0/java-jwt

1、导入依赖

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

2、生成Token

有两种方式：

  • HS256 方式

    try {
        Algorithm algorithm = Algorithm.HMAC256("secret");
        String token = JWT.create()
                    .withIssuer("rstyro")   //发布者
                    .withSubject("test")    //主题
                    .withAudience(audience)     //观众，相当于接受者
                    .withIssuedAt(new Date())   // 生成签名的时间
                    .withExpiresAt(DateUtils.offset(new Date(),2, Calendar.MINUTE))    // 生成签名的有效期,分钟
                    .withClaim("data", JSON.toJSONString("Object")) //自定义字段存数据
                    .withNotBefore(new Date())  //生效时间
                    .withJWTId(UUID.randomUUID().toString())    //编号
                    .sign(algorithm);
    } catch (JWTCreationException exception){
        //签名不匹配
    }

  • RS256 方式

    RSAPublicKey publicKey = //Get the key instance
    RSAPrivateKey privateKey = //Get the key instance
    try {
        Algorithm algorithm = Algorithm.RSA256(publicKey, privateKey);
        String token = JWT.create()
                    .withIssuer("rstyro")   //发布者
                    .withSubject("test")    //主题
                    .withAudience(audience)     //观众，相当于接受者
                    .withIssuedAt(new Date())   // 生成签名的时间
                    .withExpiresAt(DateUtils.offset(new Date(),2, Calendar.HOUR_OF_DAY))    // 生成签名的有效期,小时
                    .withClaim("data", JSON.toJSONString("Object")) //自定义字段存数据
                    .withNotBefore(new Date())  //生效时间
                    .withJWTId(UUID.randomUUID().toString())    //编号
                    .sign(algorithm);
    } catch (JWTCreationException exception){
        //签名不匹配
    }

3、校验 Token

片段代码如下：

if("RS256".equalsIgnoreCase(jwtdto.getAlg())){
	algorithm = Algorithm.RSA256(CreateSecrteKey.getRSA256Key().getPublicKey(), null);
}else {// hs256 的方式
	algorithm = Algorithm.HMAC256(secret);
}
JWTVerifier verifier = JWT.require(algorithm)
		.withIssuer("rstyro")
		.build();
try {
	verify = verifier.verify(jwtdto.getToken());
}catch (TokenExpiredException ex){
	throw new ApiException(ApiResultEnum.TOKEN_EXPIRED);
}catch (JWTVerificationException ex){
	throw new ApiException(ApiResultEnum.SIGN_VERIFI_ERROR );
}

因为 RS256 加密，需要一个公私钥对，我们可以通过 KeyPairGenerator 随机获取一个公私钥对，工具类如下：

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import top.lrshuai.jwt.entity.RSA256Key;

import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.HashMap;
import java.util.Map;

/**
 * 抄录地址：https://www.cnblogs.com/only-jlk/p/5960900.html
 */
public class CreateSecrteKey {

    public static final String KEY_ALGORITHM = "RSA";
    private static final String PUBLIC_KEY = "RSAPublicKey";
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    private static RSA256Key rsa256Key;

    //获得公钥
    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
        //获得map中的公钥对象 转为key对象
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        //byte[] publicKey = key.getEncoded();
        //编码返回字符串
        return encryptBASE64(key.getEncoded());
    }
    public static String getPublicKey(RSA256Key rsa256Key) throws Exception {
        //获得map中的公钥对象 转为key对象
        Key key = rsa256Key.getPublicKey();
        //byte[] publicKey = key.getEncoded();
        //编码返回字符串
        return encryptBASE64(key.getEncoded());
    }

    //获得私钥
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
        //获得map中的私钥对象 转为key对象
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        //byte[] privateKey = key.getEncoded();
        //编码返回字符串
        return encryptBASE64(key.getEncoded());
    }
    //获得私钥
    public static String getPrivateKey(RSA256Key rsa256Key) throws Exception {
        //获得map中的私钥对象 转为key对象
        Key key = rsa256Key.getPrivateKey();
        //byte[] privateKey = key.getEncoded();
        //编码返回字符串
        return encryptBASE64(key.getEncoded());
    }

    //解码返回byte
    public static byte[] decryptBASE64(String key) throws Exception {
        return (new BASE64Decoder()).decodeBuffer(key);
    }

    //编码返回字符串
    public static String encryptBASE64(byte[] key) throws Exception {
        return (new BASE64Encoder()).encodeBuffer(key);
    }

    //map对象中存放公私钥
    public static Map<String, Object> initKey() throws Exception {
        //  /** RSA算法要求有一个可信任的随机数源 */
        //获得对象 KeyPairGenerator 参数 RSA 1024个字节
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        //通过对象 KeyPairGenerator 生成密匙对 KeyPair
        KeyPair keyPair = keyPairGen.generateKeyPair();

        //通过对象 KeyPair 获取RSA公私钥对象RSAPublicKey RSAPrivateKey
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        //公私钥对象存入map中
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    /**
     * 获取公私钥
     * @return
     * @throws Exception
     */
    public static synchronized RSA256Key getRSA256Key() throws Exception {
        if(rsa256Key == null){
            synchronized (RSA256Key.class){
                if(rsa256Key == null) {
                    rsa256Key = new RSA256Key();
                    Map<String, Object> map = initKey();
                    rsa256Key.setPrivateKey((RSAPrivateKey) map.get(CreateSecrteKey.PRIVATE_KEY));
                    rsa256Key.setPublicKey((RSAPublicKey) map.get(CreateSecrteKey.PUBLIC_KEY));
                }
            }
        }
        return rsa256Key;
    }

    public static void main(String[] args) {
        Map<String, Object> keyMap;
        try {
            keyMap = initKey();
            String publicKey = getPublicKey(keyMap);
            System.out.println("公钥：\n"+publicKey);
            String privateKey = getPrivateKey(keyMap);
            System.out.println("私钥：\n"+privateKey);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

完整代码地址

参考链接：

-------------本文结束 感谢您的阅读-------------