一文掌握Java中的JWT

2022-06-06 18:00:14

JWT簡介

1.什麼是JWT

在介紹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就是上述流程當中token的一種具體實現方式，其全稱是JSON Web Token，官網地址：https://jwt.io/

通俗地說，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

2.1 傳統Session認證的弊端

我們知道HTTP本身是一種無狀態的協定，這就意味著如果使用者向我們的應用提供了使用者名稱和密碼來進行使用者認證，認證通過後HTTP協定不會記錄下認證後的狀態，那麼下一次請求時，使用者還要再一次進行認證，因為根據HTTP協定，我們並不知道是哪個使用者發出的請求，所以為了讓我們的應用能識別是哪個使用者發出的請求，我們只能在使用者首次登入成功後，在伺服器儲存一份使用者登入的資訊，這份登入資訊會在響應時傳遞給瀏覽器，告訴其儲存為cookie，以便下次請求時傳送給我們的應用，這樣我們的應用就能識別請求來自哪個使用者了，這是傳統的基於session認證的過程

然而，傳統的session認證有如下的問題：

每個使用者的登入資訊都會儲存到伺服器的session中，隨著使用者的增多，伺服器開銷會明顯增大
由於session是存在與伺服器的實體記憶體中，所以在分散式系統中，這種方式將會失效。雖然可以將session統一儲存到Redis中，但是這樣做無疑增加了系統的複雜性，對於不需要redis的應用也會白白多引入一個快取中介軟體
對於非瀏覽器的使用者端、手機行動端等不適用，因為session依賴於cookie，而行動端經常沒有cookie
因為session認證本質基於cookie，所以如果cookie被截獲，使用者很容易收到跨站請求偽造攻擊。並且如果瀏覽器禁用了cookie，這種方式也會失效
前後端分離系統中更加不適用，後端部署複雜，前端傳送的請求往往經過多箇中介軟體到達後端，cookie中關於session的資訊會轉發多次
由於基於Cookie，而cookie無法跨域，所以session的認證也無法跨域，對單點登入不適用

2.2 JWT認證的優勢

對比傳統的session認證方式，JWT的優勢是：

簡潔：JWT Token資料量小，傳輸速度也很快
因為JWT Token是以JSON加密形式儲存在使用者端的，所以JWT是跨語言的，原則上任何web形式都支援
不需要在伺服器端儲存對談資訊，也就是說不依賴於cookie和session，所以沒有了傳統session認證的弊端，特別適用於分散式微服務
單點登入友好：使用Session進行身份認證的話，由於cookie無法跨域，難以實現單點登入。但是，使用token進行認證的話， token可以被儲存在使用者端的任意位置的記憶體中，不一定是cookie，所以不依賴cookie，不會存在這些問題
適合行動端應用：使用Session進行身份認證的話，需要儲存一份資訊在伺服器端，而且這種方式會依賴到Cookie（需要 Cookie 儲存 SessionId），所以不適合行動端

因為這些優勢，目前無論單體應用還是分散式應用，都更加推薦用JWT token的方式進行使用者認證

JWT結構

JWT由3部分組成：檔頭(Header)、有效載荷(Payload)和簽名(Signature)。在傳輸的時候，會將JWT的3部分分別進行Base64編碼後用.進行連線形成最終傳輸的字串

JWTString=Base64(Header).Base64(Payload).HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)

1.Header

JWT頭是一個描述JWT後設資料的JSON物件，alg屬性表示簽名使用的演演算法，預設為HMAC SHA256（寫為HS256）；typ屬性表示令牌的型別，JWT令牌統一寫為JWT。最後，使用Base64 URL演演算法將上述JSON物件轉換為字串儲存

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

2.Payload

有效載荷部分，是JWT的主體內容部分，也是一個JSON物件，包含需要傳遞的資料。 JWT指定七個預設欄位供選擇

iss：發行人
exp：到期時間
sub：主題
aud：使用者
nbf：在此之前不可用
iat：釋出時間
jti：JWT ID用於標識該JWT

這些預定義的欄位並不要求強制使用。除以上預設欄位外，我們還可以自定義私有欄位，一般會把包含使用者資訊的資料放到payload中，如下例：

{
  "sub": "1234567890",
  "name": "Helen",
  "admin": true
}

請注意，預設情況下JWT是未加密的，因為只是採用base64演演算法，拿到JWT字串後可以轉換回原本的JSON資料，任何人都可以解讀其內容，因此不要構建隱私資訊欄位，比如使用者的密碼一定不能儲存到JWT中，以防止資訊洩露。JWT只是適合在網路中傳輸一些非敏感的資訊

3.Signature

簽名雜湊部分是對上面兩部分資料簽名，需要使用base64編碼後的header和payload資料，通過指定的演演算法生成雜湊，以確保資料不會被篡改。首先，需要指定一個金鑰（secret）。該密碼僅僅為儲存在伺服器中，並且不能向用戶公開。然後，使用header中指定的簽名演演算法（預設情況下為HMAC SHA256）根據以下公式生成簽名

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

在計算出簽名雜湊後，JWT頭，有效載荷和簽名雜湊的三個部分組合成一個字串，每個部分用.分隔，就構成整個JWT物件

注意JWT每部分的作用，在伺服器端接收到使用者端傳送過來的JWT token之後：
header和payload可以直接利用base64解碼出原文，從header中獲取雜湊簽名的演演算法，從payload中獲取有效資料

signature由於使用了不可逆的加密演演算法，無法解碼出原文，它的作用是校驗token有沒有被篡改。伺服器端獲取header中的加密演演算法之後，利用該演演算法加上secretKey對header、payload進行加密，比對加密後的資料和使用者端傳送過來的是否一致。注意secretKey只能儲存在伺服器端，而且對於不同的加密演演算法其含義有所不同，一般對於MD5型別的摘要加密演演算法，secretKey實際上代表的是鹽值

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

官網推薦了6個Java使用JWT的開源庫，其中比較推薦使用的是java-jwt和jjwt-root

1.java-jwt

1.1 對稱簽名

首先引入依賴

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

生成JWT的token

public class JWTTest {
    @Test
    public void testGenerateToken(){
        // 指定token過期時間為10秒
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND, 10);

        String token = JWT.create()
                .withHeader(new HashMap<>())  // Header
                .withClaim("userId", 21)  // Payload
                .withClaim("userName", "baobao")
                .withExpiresAt(calendar.getTime())  // 過期時間
                .sign(Algorithm.HMAC256("!34ADAS"));  // 簽名用的secret

        System.out.println(token);
    }
}

注意多次執行方法生成的token字串內容是不一樣的，儘管我們的payload資訊沒有變動。因為JWT中攜帶了超時時間，所以每次生成的token會不一樣，我們利用base64解密工具可以發現payload確實攜帶了超時時間

解析JWT字串

@Test
public void testResolveToken(){
    // 建立解析物件，使用的演演算法和secret要與建立token時保持一致
    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("!34ADAS")).build();
    // 解析指定的token
    DecodedJWT decodedJWT = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6ImJhb2JhbyIsImV4cCI6MTU5OTkyMjUyOCwidXNlcklkIjoyMX0.YhA3kh9KZOAb7om1C7o3vBhYp0f61mhQWWOoCrrhqvo");
    // 獲取解析後的token中的payload資訊
    Claim userId = decodedJWT.getClaim("userId");
    Claim userName = decodedJWT.getClaim("userName");
    System.out.println(userId.asInt());
    System.out.println(userName.asString());
    // 輸出超時時間
    System.out.println(decodedJWT.getExpiresAt());
}

執行後發現報異常，原因是之前生成的token已經過期

再執行一次生成token的方法，然後在過期時間10秒之內將生成的字串拷貝到解析方法中，執行解析方法即可成功

我們可以將上述方法封裝成工具類

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;
    }
}

1.2 非對稱簽名

生成jwt串的時候需要指定私鑰，解析jwt串的時候需要指定公鑰

private static final String RSA_PRIVATE_KEY = "...";
private static final String RSA_PUBLIC_KEY = "...";

/**
     * 生成token
     * @param payload token攜帶的資訊
     * @return token字串
     */
public static String getTokenRsa(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));

    // 利用hutool建立RSA
    RSA rsa = new RSA(RSA_PRIVATE_KEY, null);
    // 獲取私鑰
    RSAPrivateKey privateKey = (RSAPrivateKey) rsa.getPrivateKey();
    // 簽名時傳入私鑰
    String token = builder.withExpiresAt(calendar.getTime()).sign(Algorithm.RSA256(null, privateKey));
    return token;
}

/**
     * 解析token
     * @param token token字串
     * @return 解析後的token
     */
public static DecodedJWT decodeRsa(String token){
    // 利用hutool建立RSA
    RSA rsa = new RSA(null, RSA_PUBLIC_KEY);
    // 獲取RSA公鑰
    RSAPublicKey publicKey = (RSAPublicKey) rsa.getPublicKey();
    // 驗籤時傳入公鑰
    JWTVerifier jwtVerifier = JWT.require(Algorithm.RSA256(publicKey, null)).build();
    DecodedJWT decodedJWT = jwtVerifier.verify(token);
    return decodedJWT;
}

2.jjwt-root

2.1 對稱簽名

引入依賴

<!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

使用方法類似，可參考下列程式碼

public class JwtUtils {
    // token時效：24小時
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    // 簽名雜湊的金鑰，對於不同的加密演演算法來說含義不同
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHO";

    /**
     * 根據使用者id和暱稱生成token
     * @param id  使用者id
     * @param nickname 使用者暱稱
     * @return JWT規則生成的token
     */
    public static String getJwtToken(String id, String nickname){
        String JwtToken = Jwts.builder()
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                .setSubject("baobao-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("id", id)
                .claim("nickname", nickname)
            	// HS256演演算法實際上就是MD5加鹽值，此時APP_SECRET就代表鹽值
                .signWith(SignatureAlgorithm.HS256, APP_SECRET)
                .compact();

        return JwtToken;
    }

    /**
     * 判斷token是否存在與有效
     * @param jwtToken token字串
     * @return 如果token有效返回true，否則返回false
     */
    public static boolean checkToken(String jwtToken) {
        if(StringUtils.isEmpty(jwtToken)) return false;
        try {
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 判斷token是否存在與有效
     * @param request Http請求物件
     * @return 如果token有效返回true，否則返回false
     */
    public static boolean checkToken(HttpServletRequest request) {
        try {
            // 從http請求頭中獲取token字串
            String jwtToken = request.getHeader("token");
            if(StringUtils.isEmpty(jwtToken)) return false;
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 根據token獲取會員id
     * @param request Http請求物件
     * @return 解析token後獲得的使用者id
     */
    public static String getMemberIdByJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("token");
        if(StringUtils.isEmpty(jwtToken)) return "";
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        Claims claims = claimsJws.getBody();
        return (String)claims.get("id");
    }
}

注意：

jjwt在0.10版本以後發生了較大變化，pom依賴要引入多個

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.2</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId> <!-- or jjwt-gson if Gson is preferred -->
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>

標準規範中對各種加密演演算法的secretKey的長度有如下要求：

HS256：要求至少 256 bits (32 bytes)
HS384：要求至少384 bits (48 bytes)
HS512：要求至少512 bits (64 bytes)
RS256 and PS256：至少2048 bits
RS384 and PS384：至少3072 bits
RS512 and PS512：至少4096 bits
ES256：至少256 bits (32 bytes)
ES384：至少384 bits (48 bytes)
ES512：至少512 bits (64 bytes)

在jjwt0.10版本之前，沒有強制要求，secretKey長度不滿足要求時也可以簽名成功。但是0.10版本後強制要求secretKey滿足規範中的長度要求，否則生成jws時會丟擲異常

新版本的jjwt中，之前的簽名和驗籤方法都是傳入金鑰的字串，已經過時。最新的方法需要傳入Key物件

public class JwtUtils {
    // token時效：24小時
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    // 簽名雜湊的金鑰，對於不同的加密演演算法來說含義不同
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHOsdadasdasfdssfeweee";

    /**
     * 根據使用者id和暱稱生成token
     * @param id  使用者id
     * @param nickname 使用者暱稱
     * @return JWT規則生成的token
     */
    public static String getJwtToken(String id, String nickname){
        String JwtToken = Jwts.builder()
                .setSubject("baobao-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("id", id)
                .claim("nickname", nickname)
                // 傳入Key物件
                .signWith(Keys.hmacShaKeyFor(APP_SECRET.getBytes(StandardCharsets.UTF_8)), SignatureAlgorithm.HS256)
                .compact();
        return JwtToken;
    }

    /**
     * 判斷token是否存在與有效
     * @param jwtToken token字串
     * @return 如果token有效返回true，否則返回false
     */
    public static Jws<Claims> decode(String jwtToken) {
        // 傳入Key物件
        Jws<Claims> claimsJws = Jwts.parserBuilder().setSigningKey(Keys.hmacShaKeyFor(APP_SECRET.getBytes(StandardCharsets.UTF_8))).build().parseClaimsJws(jwtToken);
        return claimsJws;
    }
}

2.2 非對稱簽名

生成jwt串的時候需要指定私鑰，解析jwt串的時候需要指定公鑰

private static final String RSA_PRIVATE_KEY = "...";
private static final String RSA_PUBLIC_KEY = "...";

/**
     * 根據使用者id和暱稱生成token
     * @param id  使用者id
     * @param nickname 使用者暱稱
     * @return JWT規則生成的token
     */
public static String getJwtTokenRsa(String id, String nickname){
    // 利用hutool建立RSA
    RSA rsa = new RSA(RSA_PRIVATE_KEY, null);
    RSAPrivateKey privateKey = (RSAPrivateKey) rsa.getPrivateKey();
    String JwtToken = Jwts.builder()
        .setSubject("baobao-user")
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
        .claim("id", id)
        .claim("nickname", nickname)
        // 簽名指定私鑰
        .signWith(privateKey, SignatureAlgorithm.RS256)
        .compact();
    return JwtToken;
}

/**
     * 判斷token是否存在與有效
     * @param jwtToken token字串
     * @return 如果token有效返回true，否則返回false
     */
public static Jws<Claims> decodeRsa(String jwtToken) {
    RSA rsa = new RSA(null, RSA_PUBLIC_KEY);
    RSAPublicKey publicKey = (RSAPublicKey) rsa.getPublicKey();
    // 驗籤指定公鑰
    Jws<Claims> claimsJws = Jwts.parserBuilder().setSigningKey(publicKey).build().parseClaimsJws(jwtToken);
    return claimsJws;
}

實際開發中的應用

在實際的SpringBoot專案中，一般我們可以用如下流程做登入：

在登入驗證通過後，給使用者生成一個對應的隨機token(注意這個token不是指jwt，可以用uuid等演演算法生成)，然後將這個token作為key的一部分，使用者資訊作為value存入Redis，並設定過期時間，這個過期時間就是登入失效的時間
將第1步中生成的隨機token作為JWT的payload生成JWT字串返回給前端
前端之後每次請求都在請求頭中的Authorization欄位中攜帶JWT字串
後端定義一個攔截器，每次收到前端請求時，都先從請求頭中的Authorization欄位中取出JWT字串並進行驗證，驗證通過後解析出payload中的隨機token，然後再用這個隨機token得到key，從Redis中獲取使用者資訊，如果能獲取到就說明使用者已經登入

public class JWTInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String JWT = request.getHeader("Authorization");
        try {
            // 1.校驗JWT字串
            DecodedJWT decodedJWT = JWTUtils.decode(JWT);
            // 2.取出JWT字串載荷中的隨機token，從Redis中獲取使用者資訊
            ...
            return true;
        }catch (SignatureVerificationException e){
            System.out.println("無效簽名");
            e.printStackTrace();
        }catch (TokenExpiredException e){
            System.out.println("token已經過期");
            e.printStackTrace();
        }catch (AlgorithmMismatchException e){
            System.out.println("演演算法不一致");
            e.printStackTrace();
        }catch (Exception e){
            System.out.println("token無效");
            e.printStackTrace();
        }
        return false;
    }
}