Java JWT認證詳解

1. JWT簡介

JSON Web Token（JWT），是一種開放的標準（RFC 7519）。

JWT可以在通信雙方之間安全地傳遞用戶身份信息，同時因為它是開放的標準，所以可以被任何一種編程語言進行支持。

JWT有三個部分組成：Header（頭部）、Payload（負載）和Signature（簽名）。

header.payload.signature

其中Header聲明類型和簽名算法，Payload聲明所包含的信息，Signature用於驗證JWT的合法性。

2. JWT認證流程

JWT認證流程大概分為以下幾步：

1.用戶提供賬號密碼進行登錄

2.服務端驗證用戶提供的賬號密碼是否正確

3.如果賬號密碼正確，服務端生成一個JWT並返回給客戶端

4.客戶端收到JWT之後在以後的請求中帶上JWT

5.服務端對JWT進行驗證，如果合法則允許請求，否則返回錯誤信息

3. 使用Java JWT

1. 添加依賴

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

2. JWT的創建與解析

JWT的創建有點類似於數字簽名，處理過程大致分為三個步驟：

1.生成一個簽名密鑰

2.使用簽名密鑰生成JWT

3.在需要驗證JWT的時候，解析JWT，並使用相同的簽名密鑰進行驗證。

下面是一個簡單的範例：

package com.example.jwt;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;

import javax.crypto.SecretKey;

public class JwtUtil {
    private static final String KEY = "jwtsecrethhhhhhhhhhhhhhhhhhhhhhhhhhhhhh";

    public static String createJwtToken(String id, String subject, String issuer, long ttlMillis) {
        SecretKey key = Keys.hmacShaKeyFor(KEY.getBytes());

        long nowMillis = System.currentTimeMillis();
        long expMillis = nowMillis + ttlMillis;

        return Jwts.builder()
                .setId(id)
                .setSubject(subject)
                .setIssuer(issuer)
                .setExpiration(new Date(expMillis))
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();
    }

    public static Claims parseJwtToken(String jwt) {
        SecretKey key = Keys.hmacShaKeyFor(KEY.getBytes());

        return Jwts.parser()
                .setSigningKey(key)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

其中createJwtToken方法用於創建JWT，parseJwtToken方法用於解析JWT。

注意在createJwtToken方法中必須指定JWT的有效期，否則默認為永久有效。

3. JWT的驗證

當客戶端傳遞了JWT以後，服務端需要對JWT進行驗證，下面是一個簡單的範例：

package com.example.jwt;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
public class JwtTokenValidator {
    private static final Logger logger = LoggerFactory.getLogger(JwtTokenValidator.class);

    public boolean validate(String jwt) {
        try {
            Claims claims = JwtUtil.parseJwtToken(jwt);

            // TODO: 可以在這裡進行權限校驗

            return true;
        } catch (ExpiredJwtException e) {
            logger.error("Token已過期：{}", jwt);
        } catch (Exception e) {
            logger.error("Token驗證失敗：{}", jwt, e);
        }

        return false;
    }
}

其中validate方法用於驗證JWT是否有效。在此處，我們只是簡單判斷JWT是否過期，若過期則返回錯誤信息，如果需要進行更複雜的校驗，可以在TODO處進行實現。

4. Spring Security集成

Spring Security是一個非常流行的安全框架，可以與JWT非常好的集成。

1. 添加依賴

<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-jwt</artifactId>
    <version>1.1.0.RELEASE</version>
</dependency>

2. 配置JWT

在Spring Security的配置文件中添加JWT相關的配置：

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Autowired
    private JwtAuthenticationProvider jwtAuthenticationProvider;

    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().and().csrf().disable()

                .authorizeRequests()
                .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()

                .antMatchers("/login").permitAll()

                .anyRequest().authenticated()

                .and()
                .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint)

                .and()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);

        http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(jwtAuthenticationProvider);
    }

    @Bean
    public JwtAuthenticationFilter jwtAuthenticationTokenFilter() throws Exception {
        return new JwtAuthenticationFilter();
    }

    @Bean
    public JwtAuthenticationProvider jwtAuthenticationProvider() {
        return new JwtAuthenticationProvider();
    }

    @Bean
    public JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint() {
        return new JwtAuthenticationEntryPoint();
    }
}

其中配置了幾個重要的組件：

1.JwtAuthenticationEntryPoint：當用戶的JWT無效時的異常處理入口；

2.JwtAuthenticationProvider：JWT的驗證器；

3.JwtAuthenticationFilter：過濾器，用於在請求頭中獲取JWT並進行驗證。

3. JWT認證

在Spring Security的UserDetailsService實現類中進行JWT的認證，下面是一個簡單的範例：

package com.example.jwt.service;

import com.example.jwt.bean.JwtUser;
import com.example.jwt.dao.UserRepository;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import javax.crypto.SecretKey;
import javax.servlet.http.HttpServletRequest;
import java.util.Date;
import java.util.Optional;

@Service
public class JwtUserDetailsService implements UserDetailsService {
    private static final String KEY = "jwtsecrethhhhhhhhhhhhhhhhhhhhhhhhhhhhhh";

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private HttpServletRequest httpServletRequest;

    private static final Long EXPIRATION_TIME = 60L * 60L * 1000L;

    @Override
    public UserDetails loadUserByUsername(String username) {
        Optional<User> optionalUser = userRepository.findByUsername(username);

        if (optionalUser.isPresent()) {
            User user = optionalUser.get();

            return new JwtUser(user.getId(), user.getUsername(), user.getPassword());
        }

        return null;
    }

    public String createJwtToken(Authentication authentication) {
        SecretKey key = Keys.hmacShaKeyFor(KEY.getBytes());

        String username = authentication.getName();

        long nowMillis = System.currentTimeMillis();
        long expMillis = nowMillis + EXPIRATION_TIME;

        return Jwts.builder()
                .setSubject(username)
                .setIssuer(httpServletRequest.getRequestURL().toString())
                .setIssuedAt(new Date(nowMillis))
                .setExpiration(new Date(expMillis))
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();
    }

    public Authentication getAuthentication(String jwt) {
        Claims claims = Jwts.parser()
                .setSigningKey(KEY.getBytes())
                .parseClaimsJws(jwt)
                .getBody();

        String username = claims.getSubject();

        UserDetails userDetails = loadUserByUsername(username);

        return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
    }
}

其中loadUserByUsername方法用於從數據庫中查詢用戶信息，createJwtToken方法用於創建JWT，getAuthentication方法用於根據JWT獲取用戶信息，如果JWT無效返回null。

4. 總結

JWT是一個非常方便的用戶身份認證方式，它可以與各種編程語言非常好地進行集成，同時也可以與Spring Security等框架完美地進行結合。希望本文的介紹能夠對大家有所幫助。