JWT詳解

本文從本人博客搬運,原文格式更加美觀,可以移步原文閱讀:JWT詳解

JWT簡介 1.什麼是JWT

在介紹JWT之前,我們先來回顧一下利用token進行用戶身份驗證的流程:

  1. 客戶端使用用戶名和密碼請求登錄
  2. 服務端收到請求,驗證用戶名和密碼
  3. 驗證成功後,服務端會簽發一個token,再把這個token返回給客戶端
  4. 客戶端收到token後可以把它存儲起來,比如放到cookie中
  5. 客戶端每次向服務端請求資源時需要攜帶服務端簽發的token,可以在cookie或者header中攜帶
  6. 服務端收到請求,然後去驗證客戶端請求裡面帶著的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的認證流程如下:

  1. 首先,前端通過Web表單將自己的用戶名和密碼發送到後端的接口,這個過程一般是一個POST請求。建議的方式是通過SSL加密的傳輸(HTTPS),從而避免敏感信息被嗅探
  2. 後端核對用戶名和密碼成功後,將包含用戶信息的數據作為JWT的Payload,將其與JWT Header分別進行Base64編碼拼接後簽名,形成一個JWT Token,形成的JWT Token就是一個如同lll.zzz.xxx的字符串
  3. 後端將JWT Token字符串作為登錄成功的結果返回給前端。前端可以將返回的結果保存在瀏覽器中,退出登錄時刪除保存的JWT Token即可
  4. 前端在每次請求時將JWT Token放入HTTP請求頭中的Authorization屬性中(解決XSS和XSRF問題)
  5. 後端檢查前端傳過來的JWT Token,驗證其有效性,比如檢查簽名是否正確、是否過期、token的接收方是否是自己等等
  6. 驗證通過後,後端解析出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編碼後用.進行連接形成最終傳輸的字符串
J W T S t r i n g = B a s e 64 ( H e a d e r ) . B a s e 64 ( P a y l o a d ) . H M A C S H A 256 ( b a s e 64 U r l E n c o d e ( h e a d e r ) + ” . ” + b a s e 64 U r l E n c o d e ( p a y l o a d ) , s e c r e t ) JWTString = Base64(Header).Base64(Payload).HMACSHA256(base64UrlEncode(header) + “.” + base64UrlEncode(payload), secret) 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)根據以下公式生成簽名
H M A C S H A 256 ( b a s e 64 U r l E n c o d e ( h e a d e r ) + ” . ” + b a s e 64 U r l E n c o d e ( p a y l o a d ) , s e c r e t ) HMACSHA256(base64UrlEncode(header) + “.” + base64UrlEncode(payload), secret) HMACSHA256(base64UrlEncode(header)+.+base64UrlEncode(payload),secret)
在計算出簽名哈希後,JWT頭,有效載荷和簽名哈希的三個部分組合成一個字符串,每個部分用.分隔,就構成整個JWT對象

註意JWT每部分的作用,在服務端接收到客戶端發送過來的JWT token之後:

  • headerpayload可以直接利用base64解碼出原文,從header中獲取哈希簽名的算法,從payload中獲取有效數據
  • signature由於使用瞭不可逆的加密算法,無法解碼出原文,它的作用是校驗token有沒有被篡改。服務端獲取header中的加密算法之後,利用該算法加上secretKeyheaderpayload進行加密,比對加密後的數據和客戶端發送過來的是否一致。註意secretKey隻能保存在服務端,而且對於不同的加密算法其含義有所不同,一般對於MD5類型的摘要加密算法,secretKey實際上代表的是鹽值

JWT的種類

其實JWT(JSON Web Token)指的是一種規范,這種規范允許我們使用JWT在兩個組織之間傳遞安全可靠的信息,JWT的具體實現可以分為以下幾種:

  • nonsecure JWT:未經過簽名,不安全的JWT
  • JWS:經過簽名的JWT
  • JWEpayload部分經過加密的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-jwtjjwt-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字符串

@Testpublic 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 對稱簽名

引入依賴

<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>     <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項目中,一般我們可以用如下流程做登錄:

  1. 在登錄驗證通過後,給用戶生成一個對應的隨機token(註意這個token不是指jwt,可以用uuid等算法生成),然後將這個token作為key的一部分,用戶信息作為value存入Redis,並設置過期時間,這個過期時間就是登錄失效的時間
  2. 將第1步中生成的隨機token作為JWT的payload生成JWT字符串返回給前端
  3. 前端之後每次請求都在請求頭中的Authorization字段中攜帶JWT字符串
  4. 後端定義一個攔截器,每次收到前端請求時,都先從請求頭中的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;    }}

在實際開發中需要用下列手段來增加JWT的安全性:

  • 因為JWT是在請求頭中傳遞的,所以為瞭避免網絡劫持,推薦使用HTTPS來傳輸,更加安全
  • JWT的哈希簽名的密鑰是存放在服務端的,所以隻要服務器不被攻破,理論上JWT是安全的。因此要保證服務器的安全
  • JWT可以使用暴力窮舉來破解,所以為瞭應對這種破解方式,可以定期更換服務端的哈希簽名密鑰(相當於鹽值)。這樣可以保證等破解結果出來瞭,你的密鑰也已經換瞭