SpringBoot使用JWT實現登陸驗證

什麼是JWT

JSON Web Token（JWT）是一個開放的標準（RFC 7519），它定義了一個緊湊且自包含的方式，用於在各方之間以JSON對象安全地傳輸信息。這些信息能夠經過數字簽名進行驗證和信任。可使用祕密（使用HMAC算法）或使用RSA的公鑰/私鑰對來對JWT進行簽名。
具體的jwt介紹能夠查看官網的介紹： https://jwt.io/introduction/

jwt請求流程

引用官網的圖片

中文介紹：

1. 用戶使用帳號和麪發出post請求；
2. 服務器使用私鑰建立一個jwt；
3. 服務器返回這個jwt給瀏覽器；
4. 瀏覽器將該jwt串在請求頭中像服務器發送請求；
5. 服務器驗證該jwt；
6. 返回響應的資源給瀏覽器。

jwt組成

jwt含有三部分：頭部（header）、載荷（payload）、簽證（signature）

頭部（header）

頭部通常有兩部分信息：聲明類型、聲明加密的算法（一般使用HMAC SHA256）
頭部通常使用base64加密：eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9
解密後：

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

載荷（payload）

該部分通常存放一些有效的信息。jwt的標準定義包含五個字段：

• iss：該JWT的簽發者
• sub: 該JWT所面向的用戶
• aud: 接收該JWT的一方
• exp(expires): 何時過時，這裏是一個Unix時間戳
• iat(issued at): 在何時簽發的

這個只是JWT的定義標準，不強制使用。另外本身也能夠添加一些公開的不涉及安全的方面的信息。

簽證（signature）

JWT最後一個部分。該部分是使用了HS256加密後的數據；包含三個部分：

• header (base64後的)
• payload (base64後的)
• secret 私鑰

secret是保存在服務器端的，jwt的簽發生成也是在服務器端的，secret就是用來進行jwt的簽發和jwt的驗證，因此，它就是你服務端的私鑰，在任何場景都不該該流露出去。一旦客戶端得知這個secret, 那就意味着客戶端是能夠自我簽發jwt了。

在SpringBoot項目中應用

首先須要添加JWT的依賴：

<dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.6.0</version>
    </dependency>

接下來在配置文件中添加JWT的配置信息：

##jwt配置
audience:
  clientId: 098f6bcd4621d373cade4e832627b4f6
  base64Secret: MDk4ZjZiY2Q0NjIxZDM3M2NhZGU0ZTgzMjYyN2I0ZjY=
  name: restapiuser
  expiresSecond: 172800

配置信息的實體類，以便獲取jwt的配置：

@Data
@ConfigurationProperties(prefix = "audience")
@Component
public class Audience {

    private String clientId;
    private String base64Secret;
    private String name;
    private int expiresSecond;

}

JWT驗證主要是經過攔截器驗證，因此咱們須要添加一個攔截器來驗證請求頭中是否含有後臺頒發的token，這裏請求頭的格式：這裏bearer;後面就是服務器頒發的token

public class JwtFilter extends GenericFilterBean {

    @Autowired
    private Audience audience;

    /**
     *  Reserved claims（保留），它的含義就像是編程語言的保留字同樣，屬於JWT標準裏面規定的一些claim。JWT標準裏面定好的claim有：

     iss(Issuser)：表明這個JWT的簽發主體；
     sub(Subject)：表明這個JWT的主體，即它的全部人；
     aud(Audience)：表明這個JWT的接收對象；
     exp(Expiration time)：是一個時間戳，表明這個JWT的過時時間；
     nbf(Not Before)：是一個時間戳，表明這個JWT生效的開始時間，意味着在這個時間以前驗證JWT是會失敗的；
     iat(Issued at)：是一個時間戳，表明這個JWT的簽發時間；
     jti(JWT ID)：是JWT的惟一標識。
     * @param req
     * @param res
     * @param chain
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void doFilter(final ServletRequest req, final ServletResponse res, final FilterChain chain)
            throws IOException, ServletException {

        final HttpServletRequest request = (HttpServletRequest) req;
        final HttpServletResponse response = (HttpServletResponse) res;
        //等到請求頭信息authorization信息
        final String authHeader = request.getHeader("authorization");

        if ("OPTIONS".equals(request.getMethod())) {
            response.setStatus(HttpServletResponse.SC_OK);
            chain.doFilter(req, res);
        } else {

            if (authHeader == null || !authHeader.startsWith("bearer;")) {
                throw new LoginException(ResultEnum.LOGIN_ERROR);
            }
            final String token = authHeader.substring(7);

            try {
                if(audience == null){
                    BeanFactory factory = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
                    audience = (Audience) factory.getBean("audience");
                }
                final Claims claims = JwtHelper.parseJWT(token,audience.getBase64Secret());
                if(claims == null){
                    throw new LoginException(ResultEnum.LOGIN_ERROR);
                }
                request.setAttribute(Constants.CLAIMS, claims);
            } catch (final Exception e) {
                throw new LoginException(ResultEnum.LOGIN_ERROR);
            }

            chain.doFilter(req, res);
        }
    }
}

註冊JWT攔截器，能夠在配置類中，也能夠直接在SpringBoot的入口類中

@Bean
    public FilterRegistrationBean jwtFilter() {
        final FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(new JwtFilter());
        //添加須要攔截的url
        List<String>  urlPatterns = Lists.newArrayList();
        urlPatterns.add("/article/insert");
        registrationBean.addUrlPatterns(urlPatterns.toArray(new String[urlPatterns.size()]));
        return registrationBean;
    }

登陸處理，也就是jwt的頒發

@PostMapping("login")
    public ResultVo login(@RequestParam(value = "usernameOrEmail", required = true) String usernameOrEmail,
                          @RequestParam(value = "password", required = true) String password,
                          HttpServletRequest request) {
        Boolean is_email = MatcherUtil.matcherEmail(usernameOrEmail);
        User user = new User();
        if (is_email) {
            user.setEmail(usernameOrEmail);
        } else {
            user.setUsername(usernameOrEmail);
        }
        User query_user = userService.get(user);
        if (query_user == null) {
            return ResultVOUtil.error("400", "用戶名或郵箱錯誤");
        }
        //驗證密碼
        PasswordEncoder encoder = new BCryptPasswordEncoder();
        boolean is_password = encoder.matches(password, query_user.getPassword());
        if (!is_password) {
            //密碼錯誤，返回提示
            return ResultVOUtil.error("400", "密碼錯誤");
        }
     
       String jwtToken = JwtHelper.createJWT(query_user.getUsername(),
                                           query_user.getId(),
                                           query_user.getRole().toString(),
                                           audience.getClientId(),
                                           audience.getName(),
                                           audience.getExpiresSecond()*1000,
                                           audience.getBase64Secret());

        String result_str = "bearer;" + jwtToken;
        return ResultVOUtil.success(result_str);
    }

這裏將jwt的頒發處理抽離出來了，JWT工具類：

public class JwtHelper {

    /**
     * 解析jwt
     */
    public static Claims parseJWT(String jsonWebToken, String base64Security){
        try
        {
            Claims claims = Jwts.parser()
                    .setSigningKey(DatatypeConverter.parseBase64Binary(base64Security))
                    .parseClaimsJws(jsonWebToken).getBody();
            return claims;
        }
        catch(Exception ex)
        {
            return null;
        }
    }

    /**
     * 構建jwt
     */
    public static String createJWT(String name, String userId, String role,
                                   String audience, String issuer, long TTLMillis, String base64Security)
    {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);

        //生成簽名密鑰
        byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(base64Security);
        Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());

        //添加構成JWT的參數
        JwtBuilder builder = Jwts.builder().setHeaderParam("typ", "JWT")
                .claim("role", role)
                .claim("unique_name", name)
                .claim("userid", userId)
                .setIssuer(issuer)
                .setAudience(audience)
                .signWith(signatureAlgorithm, signingKey);
        //添加Token過時時間
        if (TTLMillis >= 0) {
            long expMillis = nowMillis + TTLMillis;
            Date exp = new Date(expMillis);
            builder.setExpiration(exp).setNotBefore(now);
        }

        //生成JWT
        return builder.compact();
    }
}

最後，jwt可能會出現跨域的問題，因此最好添加一下對跨域的處理

@Configuration
public class CorsConfig {

    @Bean
    public FilterRegistrationBean corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");
        config.addAllowedMethod("OPTIONS");
        config.addAllowedMethod("HEAD");
        config.addAllowedMethod("GET");
        config.addAllowedMethod("PUT");
        config.addAllowedMethod("POST");
        config.addAllowedMethod("DELETE");
        config.addAllowedMethod("PATCH");
        source.registerCorsConfiguration("/**", config);
        final FilterRegistrationBean bean = new FilterRegistrationBean(new CorsFilter(source));
        bean.setOrder(0);
        return bean;
    }

    @Bean
    public WebMvcConfigurer mvcConfigurer() {
        return new WebMvcConfigurerAdapter() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**").allowedMethods("GET", "PUT", "POST", "GET", "OPTIONS");
            }
        };
    }
}

---

參考：

• 什麼是 JWT -- JSON WEB TOKEN
• JSON Web Token - 在Web應用間安全地傳遞信息