JWT簡介

1.什么是JWT

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

1. 客戶端使用用戶名和密碼請求登錄
2. 服務端收到請求，驗證用戶名和密碼
3. 驗證成功后，服務端會簽發(fā)一個token，再把這個token返回給客戶端
4. 客戶端收到token后可以把它存儲起來，比如放到cookie中
5. 客戶端每次向服務端請求資源時需要攜帶服務端簽發(fā)的token，可以在cookie或者header中攜帶
6. 服務端收到請求，然后去驗證客戶端請求里面帶著的token，如果驗證成功，就向客戶端返回請求數(shù)據(jù)

這種基于token的認證方式相比傳統(tǒng)的session認證方式更節(jié)約服務器資源，并且對移動端和分布式更加友好。其優(yōu)點如下：

• 支持跨域訪問：cookie是無法跨域的，而token由于沒有用到cookie(前提是將token放到請求頭中)，所以跨域后不會存在信息丟失問題
• 無狀態(tài)：token機制在服務端不需要存儲session信息，因為token自身包含了所有登錄用戶的信息，所以可以減輕服務端壓力
• 更適用CDN：可以通過內(nèi)容分發(fā)網(wǎng)絡請求服務端的所有資料
• 更適用于移動端：當客戶端是非瀏覽器平臺時，cookie是不被支持的，此時采用token認證方式會簡單很多
• 無需考慮CSRF：由于不再依賴cookie，所以采用token認證方式不會發(fā)生CSRF，所以也就無需考慮CSRF的防御

而JWT就是上述流程當中token的一種具體實現(xiàn)方式，其全稱是JSON Web Token，官網(wǎng)地址：https://jwt.io/

通俗地說，JWT的本質(zhì)就是一個字符串，它是將用戶信息保存到一個Json字符串中，然后進行編碼后得到一個JWT token，并且這個JWT token帶有簽名信息，接收后可以校驗是否被篡改，所以可以用于在各方之間安全地將信息作為Json對象傳輸。JWT的認證流程如下：

1. 首先，前端通過Web表單將自己的用戶名和密碼發(fā)送到后端的接口，這個過程一般是一個POST請求。建議的方式是通過SSL加密的傳輸(HTTPS)，從而避免敏感信息被嗅探
2. 后端核對用戶名和密碼成功后，將包含用戶信息的數(shù)據(jù)作為JWT的Payload，將其與JWT Header分別進行Base64編碼拼接后簽名，形成一個JWT Token，形成的JWT Token就是一個如同lll.zzz.xxx的字符串
3. 后端將JWT Token字符串作為登錄成功的結(jié)果返回給前端。前端可以將返回的結(jié)果保存在瀏覽器中，退出登錄時刪除保存的JWT Token即可
4. 前端在每次請求時將JWT Token放入HTTP請求頭中的Authorization屬性中(解決XSS和XSRF問題)
5. 后端檢查前端傳過來的JWT Token，驗證其有效性，比如檢查簽名是否正確、是否過期、token的接收方是否是自己等等
6. 驗證通過后，后端解析出JWT Token中包含的用戶信息，進行其他邏輯操作(一般是根據(jù)用戶信息得到權(quán)限等)，返回結(jié)果

2.為什么要用JWT

2.1 傳統(tǒng)Session認證的弊端

我們知道HTTP本身是一種無狀態(tài)的協(xié)議，這就意味著如果用戶向我們的應用提供了用戶名和密碼來進行用戶認證，認證通過后HTTP協(xié)議不會記錄下認證后的狀態(tài)，那么下一次請求時，用戶還要再一次進行認證，因為根據(jù)HTTP協(xié)議，我們并不知道是哪個用戶發(fā)出的請求，所以為了讓我們的應用能識別是哪個用戶發(fā)出的請求，我們只能在用戶首次登錄成功后，在服務器存儲一份用戶登錄的信息，這份登錄信息會在響應時傳遞給瀏覽器，告訴其保存為cookie，以便下次請求時發(fā)送給我們的應用，這樣我們的應用就能識別請求來自哪個用戶了，這是傳統(tǒng)的基于session認證的過程

然而，傳統(tǒng)的session認證有如下的問題：

• 每個用戶的登錄信息都會保存到服務器的session中，隨著用戶的增多，服務器開銷會明顯增大
• 由于session是存在與服務器的物理內(nèi)存中，所以在分布式系統(tǒng)中，這種方式將會失效。雖然可以將session統(tǒng)一保存到Redis中，但是這樣做無疑增加了系統(tǒng)的復雜性，對于不需要redis的應用也會白白多引入一個緩存中間件
• 對于非瀏覽器的客戶端、手機移動端等不適用，因為session依賴于cookie，而移動端經(jīng)常沒有cookie
• 因為session認證本質(zhì)基于cookie，所以如果cookie被截獲，用戶很容易收到跨站請求偽造攻擊。并且如果瀏覽器禁用了cookie，這種方式也會失效
• 前后端分離系統(tǒng)中更加不適用，后端部署復雜，前端發(fā)送的請求往往經(jīng)過多個中間件到達后端，cookie中關于session的信息會轉(zhuǎn)發(fā)多次
• 由于基于Cookie，而cookie無法跨域，所以session的認證也無法跨域，對單點登錄不適用

2.2 JWT認證的優(yōu)勢

對比傳統(tǒng)的session認證方式，JWT的優(yōu)勢是：

• 簡潔：JWT Token數(shù)據(jù)量小，傳輸速度也很快
• 因為JWT Token是以JSON加密形式保存在客戶端的，所以JWT是跨語言的，原則上任何web形式都支持
• 不需要在服務端保存會話信息，也就是說不依賴于cookie和session，所以沒有了傳統(tǒng)session認證的弊端，特別適用于分布式微服務
• 單點登錄友好：使用Session進行身份認證的話，由于cookie無法跨域，難以實現(xiàn)單點登錄。但是，使用token進行認證的話， token可以被保存在客戶端的任意位置的內(nèi)存中，不一定是cookie，所以不依賴cookie，不會存在這些問題
• 適合移動端應用：使用Session進行身份認證的話，需要保存一份信息在服務器端，而且這種方式會依賴到Cookie（需要 Cookie 保存 SessionId），所以不適合移動端

因為這些優(yōu)勢，目前無論單體應用還是分布式應用，都更加推薦用JWT token的方式進行用戶認證

JWT結(jié)構(gòu)

JWT由3部分組成：標頭(Header)、有效載荷(Payload)和簽名(Signature)。在傳輸?shù)臅r候，會將JWT的3部分分別進行Base64編碼后用.進行連接形成最終傳輸?shù)淖址甁 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元數(shù)據(jù)的JSON對象，alg屬性表示簽名使用的算法，默認為HMAC SHA256（寫為HS256）；typ屬性表示令牌的類型，JWT令牌統(tǒng)一寫為JWT。最后，使用Base64 URL算法將上述JSON對象轉(zhuǎn)換為字符串保存

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

2.Payload

有效載荷部分，是JWT的主體內(nèi)容部分，也是一個JSON對象，包含需要傳遞的數(shù)據(jù)。 JWT指定七個默認字段供選擇

iss：發(fā)行人
exp：到期時間
sub：主題
aud：用戶
nbf：在此之前不可用
iat：發(fā)布時間
jti：JWT ID用于標識該JWT

這些預定義的字段并不要求強制使用。除以上默認字段外，我們還可以自定義私有字段，一般會把包含用戶信息的數(shù)據(jù)放到payload中，如下例：

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

請注意，默認情況下JWT是未加密的，因為只是采用base64算法，拿到JWT字符串后可以轉(zhuǎn)換回原本的JSON數(shù)據(jù)，任何人都可以解讀其內(nèi)容，因此不要構(gòu)建隱私信息字段，比如用戶的密碼一定不能保存到JWT中，以防止信息泄露。JWT只是適合在網(wǎng)絡中傳輸一些非敏感的信息

3.Signature

簽名哈希部分是對上面兩部分數(shù)據(jù)簽名，需要使用base64編碼后的header和payload數(shù)據(jù)，通過指定的算法生成哈希，以確保數(shù)據(jù)不會被篡改。首先，需要指定一個密鑰（secret）。該密碼僅僅為保存在服務器中，并且不能向用戶公開。然后，使用header中指定的簽名算法（默認情況下為HMAC SHA256）根據(jù)以下公式生成簽名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頭，有效載荷和簽名哈希的三個部分組合成一個字符串，每個部分用.分隔，就構(gòu)成整個JWT對象

注意JWT每部分的作用，在服務端接收到客戶端發(fā)送過來的JWT token之后：

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

JWT的種類

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

• nonsecure JWT：未經(jīng)過簽名，不安全的JWT
• JWS：經(jīng)過簽名的JWT
• JWE：payload部分經(jīng)過加密的JWT

1.nonsecure JWT

未經(jīng)過簽名，不安全的JWT。其header部分沒有指定簽名算法

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

并且也沒有Signature部分

2.JWS

JWS ，也就是JWT Signature，其結(jié)構(gòu)就是在之前nonsecure JWT的基礎上，在頭部聲明簽名算法，并在最后添加上簽名。創(chuàng)建簽名，是保證jwt不能被他人隨意篡改。我們通常使用的JWT一般都是JWS

為了完成簽名，除了用到header信息和payload信息外，還需要算法的密鑰，也就是secretKey。加密的算法一般有2類：

• 對稱加密：secretKey指加密密鑰，可以生成簽名與驗簽
• 非對稱加密：secretKey指私鑰，只用來生成簽名，不能用來驗簽(驗簽用的是公鑰)

JWT的密鑰或者密鑰對，一般統(tǒng)一稱為JSON Web Key，也就是JWK

到目前為止，jwt的簽名算法有三種：

• HMAC【哈希消息驗證碼(對稱)】：HS256/HS384/HS512
• RSASSA【RSA簽名算法(非對稱)】（RS256/RS384/RS512）
• ECDSA【橢圓曲線數(shù)據(jù)簽名算法(非對稱)】（ES256/ES384/ES512）

Java中使用JWT

官網(wǎng)推薦了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字符串內(nèi)容是不一樣的，盡管我們的payload信息沒有變動。因為JWT中攜帶了超時時間，所以每次生成的token會不一樣，我們利用base64解密工具可以發(fā)現(xiàn)payload確實攜帶了超時時間

解析JWT字符串

@Test
public void testResolveToken(){
    // 創(chuàng)建解析對象，使用的算法和secret要與創(chuàng)建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());
}

運行后發(fā)現(xiàn)報異常，原因是之前生成的token已經(jīng)過期

再運行一次生成token的方法，然后在過期時間10秒之內(nèi)將生成的字符串拷貝到解析方法中，運行解析方法即可成功

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

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();
        // 構(gòu)建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();
    // 構(gòu)建payload
    payload.forEach((k,v) -> builder.withClaim(k,v));
    // 利用hutool創(chuàng)建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創(chuàng)建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";
    /**
     * 根據(jù)用戶id和昵稱生成token
     * @param id  用戶id
     * @param nickname 用戶昵稱
     * @return JWT規(guī)則生成的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;
    }
    /**
     * 根據(jù)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版本以后發(fā)生了較大變化，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>

• 標準規(guī)范中對各種加密算法的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滿足規(guī)范中的長度要求，否則生成jws時會拋出異常

  

• 新版本的jjwt中，之前的簽名和驗簽方法都是傳入密鑰的字符串，已經(jīng)過時。最新的方法需要傳入Key對象

public class JwtUtils {
    // token時效：24小時
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    // 簽名哈希的密鑰，對于不同的加密算法來說含義不同
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHOsdadasdasfdssfeweee";
    /**
     * 根據(jù)用戶id和昵稱生成token
     * @param id  用戶id
     * @param nickname 用戶昵稱
     * @return JWT規(guī)則生成的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 = "...";
/**
     * 根據(jù)用戶id和昵稱生成token
     * @param id  用戶id
     * @param nickname 用戶昵稱
     * @return JWT規(guī)則生成的token
     */
public static String getJwtTokenRsa(String id, String nickname){
    // 利用hutool創(chuàng)建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;
}

實際開發(fā)中的應用

在實際的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中獲取用戶信息，如果能獲取到就說明用戶已經(jīng)登錄

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已經(jīng)過期");
            e.printStackTrace();
        }catch (AlgorithmMismatchException e){
            System.out.println("算法不一致");
            e.printStackTrace();
        }catch (Exception e){
            System.out.println("token無效");
            e.printStackTrace();
        }
        return false;
    }
}

在實際開發(fā)中需要用下列手段來增加JWT的安全性：

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

最新評論