# 1. Sử dụng JWT trong Spring Boot ## 1.1 Giới thiệu `JWT (JSON Web Token)` là một chuẩn mở để truyền dữ liệu an toàn giữa hai bên dưới dạng JSON. `JWT` được sử dụng rộng rãi trong việc xác thực người dùng và truyền dữ liệu an toàn giữa các hệ thống. `JWT` bao gồm 3 phần, mỗi phần được ngăn cách bằng dấu chấm `.`: - Header: Chứa thông tin về loại token và thuật toán mã hóa. + `alg`: Thuật toán mã hóa. + `typ`: Loại token. - Payload: Chứa thông tin về người dùng. + `sub`: Subject, chủ thể của token. + `exp`: Expiration time, thời gian hết hạn của token. + `iat`: Issued At, thời gian phát hành token. + `iss`: Issuer, người phát hành token. + `aud`: Audience, người nhận token. - Signature: Chữ ký số để xác thực token, bao gồm header, payload và secret key. ## 1.2. JWT Authentication sử dụng Spring Boot's OAuth2 Resource Server Để sử dụng `JWT` trong `Spring Boot`, chúng ta sử dụng `Spring Boot's OAuth2 Resource Server`. `Spring Boot's OAuth2 Resource Server` hỗ trợ tích hợp `OAuth2` để xác thực người dùng sử dụng `JWT`: > `pom.xml` ```xml org.springframework.boot spring-boot-starter-oauth2-resource-server ``` Chúng ta thực hiện các bước sau để sử dụng `JWT` trong `Spring Boot`: - 1. Tạo key pair: Sử dụng `java.security.KeyPairGenerator` để tạo key pair. Hoặc sử dụng `openssl` để tạo key pair. - 2. Tạo đối tượng khóa `RSA` sử dụng key pair: Sử dụng `com.nimbusds.jose.jwk.RSAKey` để tạo đối tượng khóa `RSA`. - 3. Tạo `JWKSource` (JSON Web Key Source) để cung cấp khóa `RSA` + Tạo `JWKSet` để lưu trữ khóa `RSA`. + Tạo `JWKSource` từ `JWKSet`. - 4. Sử dụng khóa công khai `RSA` để giải mã token: Sử dụng `NimbusJwtDecoder.withPublicKey(rsaKey.toRSAPublicKey()).build()` để giải mã token. - 5. Sử dụng `JWKSource` cho việc mã hóa: trả về `return new NimbusJwsEncoder(jwkSource);` trong `@Bean` của `WebSecurityConfigurerAdapter`. ### 1.2.1. Cấu hình JWT với Spring Security 1. Chúng ta cấu hình `JWT` với `Spring Security` bằng việc thêm `SecurityFilterChain` để bật o2auth2 `Resource Server`: ```java import org.springframework.security.web.SecurityFilterChain; ... @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception{ // Cấu hình JWT với Spring Security // Authorize Requests http.authorizeHttpRequests(req -> req.anyRequest().authenticated()) // Tất cả các request đều cần xác thực .httpBasic(withDefaults()) // Sử dụng HTTP Basic Authentication .cors(cors -> cors.disable()) // Tắt CORS .csrf(csrf -> csrf.disable()) // Tắt CSRF .headers(headers -> headers.frameOptions(frameOptions -> frameOptions.sameOrigin())) // X-Frame-Options: SAMEORIGIN .oauth2ResourceServer(oauth2 -> oauth2.jwt(withDefaults())); // Sử dụng JWT để xác thực người dùng khi truy cập vào các resource server (route API) return http.build(); } ... ``` 2. Tạo `KeyPair`: ```java import java.security.KeyPair; import java.security.KeyPairGenerator; ... @Bean public KeyPair keyPair() throws Exception{ // Tạo một KeyPair bao gồm public key và private key KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); // Sử dụng thuật toán RSA keyPairGenerator.initialize(2048); // Khởi tạo key với độ dài 2048 bits return keyPairGenerator.generateKeyPair(); // Trả về một KeyPair } ... ``` 3. Tạo đối tượng khóa `RSA` sử dụng `KeyPair`: ```java import com.nimbusds.jose.jwk.RSAKey; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.interfaces.RSAPublicKey; import java.util.UUID; ... @Bean public RSAKey rsaKey(KeyPair keyPair) { // Tạo một RSAKey từ KeyPair return new RSAKey.Builder((RSAPublicKey) keyPair.getPublic()) // Sử dụng public key .privateKey(keyPair.getPrivate()) // Sử dụng private key .keyID(UUID.randomUUID().toString()) // Tạo một keyID ngẫu nhiên .build(); // Tạo một RSAKey } ... ``` 4. Tạo `JWKSource` để cung cấp khóa `RSA` cho việc mã hóa: ```java import com.nimbusds.jose.jwk.JWKSet; import com.nimbusds.jose.jwk.RSAKey; import com.nimbusds.jose.jwk.source.JWKSource; import com.nimbusds.jose.proc.SecurityContext; ... @Bean public JWKSource jwkSource(RSAKey rsaKey) { // Tạo một JWKSource từ RSAKey JWKSet jwkSet = new JWKSet(rsaKey); // Tạo một JWKSet từ RSAKey return (jwkSelector, context) -> jwkSelector.select(jwkSet); // Trả về một JWKSource } ... ``` 5. Sử dụng khóa công khai `RSA` để giải mã token: ```java import com.nimbusds.jose.JOSEException; import com.nimbusds.jose.jwk.RSAKey; import org.springframework.security.oauth2.jwt.JwtDecoder; import org.springframework.security.oauth2.jwt.NimbusJwtDecoder; ... @Bean public JwtDecoder jwtDecoder(RSAKey rsaKey) throws JOSEException { // Tạo một JwtDecoder từ RSAKey để giải mã token JWT return NimbusJwtDecoder.withPublicKey(rsaKey.toRSAPublicKey()).build(); // Trả về một JwtDecoder } ... ``` 6. Tạo phương thức dùng để mã hóa JWKSource: ```java import org.springframework.context.annotation.Bean; import com.nimbusds.jose.jwk.source.JWKSource; import com.nimbusds.jose.proc.SecurityContext; import org.springframework.security.oauth2.jwt.NimbusJwtEncoder; import org.springframework.security.oauth2.jwt.JwtEncoder; ... @Bean public JwtEncoder jwtEncoder(JWKSource jwkSource) { return new NimbusJwtEncoder(jwkSource); // Trả về một JwtEncoder từ JWKSource, sử dụng NimbusJwtEncoder } ... ``` ### 1.2.2. Tạo API để xác thực người dùng, tạo và trả về JWT token để người dùng sử dụng > `JWTController.java` ```java package com.didan.learn_spring_security; import java.time.Instant; import java.util.stream.Collectors; import org.springframework.security.core.Authentication; import org.springframework.security.oauth2.jwt.JwtClaimsSet; import org.springframework.security.oauth2.jwt.JwtEncoder; import org.springframework.security.oauth2.jwt.JwtEncoderParameters; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class JwtAuthenticationController { private final JwtEncoder jwtEncoder; // Inject JwtEncoder (từ class JWTSecurityConfig) vào JwtAuthenticationController để mã hóa token JWT public JwtAuthenticationController(JwtEncoder jwtEncoder) { this.jwtEncoder = jwtEncoder; } @PostMapping("/authenticate") // Phương thức để xác thực người dùng, lấy token sau khi xác thực public JwtResponse authenticate(Authentication authentication) { // Authentication là một interface, nó chứa thông tin về người dùng sau khi xác thực Basic Authentication return new JwtResponse(createToken(authentication)); // Trả về token sau khi xác thực } private String createToken(Authentication authentication) { // Tạo token JWT từ thông tin người dùng sau khi xác thực JwtClaimsSet claims = JwtClaimsSet.builder() // Tạo claims cho token JWT .issuer("self") // Issuer của token là chính nó .issuedAt(Instant.now()) // Thời gian phát hành token .expiresAt(Instant.now().plusSeconds(60 * 15)) // Token hết hạn sau 15 phút .subject(authentication.getName()) // Subject của token là username của người dùng (có thể lấy bằng cáhc autthentication.getPricipal()); .claim("scope", createScope(authentication)) // Tạo thêm trường tùy chỉnh trong body payload của token JWT, ở đây là scope .build(); // Tạo claims JwtEncoderParameters jwtEncoderParameters = JwtEncoderParameters.from(claims); // Tạo JwtEncoderParameters từ claims vừa tạo return jwtEncoder.encode(jwtEncoderParameters).getTokenValue(); // Mã hóa token JWT từ JwtEncoderParameters và trả về token } private String createScope(Authentication authentication) { // Tạo scope từ thông tin người dùng sau khi xác thực return authentication.getAuthorities().stream() // Lấy danh sách các quyền của người dùng sau khi xác thực .map(a -> a.getAuthority()) // Lấy tên của quyền .collect(Collectors.joining(" ")); // Nối tất cả các tên quyền lại với nhau và ngăn cách bằng dấu cách } } record JwtResponse(String token) {}; // Class này dùng để trả về token sau khi xác thực, sử dụng record để tạo class với constructor tự động ``` ## 1.3. Sử dụng JWT với Spring Security Database Authentication (Tắt Basic Authentication) ### 1.3.1. Tắt Basic Authentication ```java ... .httpBasic(httpBasic -> httpBasic.disable()) .formLogin(formLogin -> formLogin.disable()) ... ``` ### 1.3.2. Cấu hình `UserDetailsService` để xác thực người dùng từ database. Để thay vì lưu trữ `User` trong `H2-Database`, chúng ta có thể lưu trữ `User` trong `Database` bên ngoài như `MYSQL`. Sử dụng `JDBC`, `JPA` để kết nối với `MYSQL`. Cấu hình kết nối với `MYSQL` xem ở `08. JPA, Hibernate, JDBC.md`. ### 1.3.2.1. Cấu hình `CustomUserDetailsService` để xác thực `User` trong `MYSQL` Mặc định, `Spring Security` sử dụng `UserDetailsService` để xác thực `User` trong `In-Memory` hoặc `Database` của chính ứng dụng. Để xác thực `User` trong `Database` bên ngoài, chúng ta cần tạo một class `CustomUserDetailsService` và implement `UserDetailsService`. Và gán cho nó là `@Service`. >CustomUserDetails.java ```java package com.didan.authdb; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.stream.Collectors; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.authority.SimpleGrantedAuthority; import org.springframework.security.core.userdetails.User; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.core.userdetails.UsernameNotFoundException; import org.springframework.stereotype.Service; @Service public class CustomUserDetails implements UserDetailsService { // Kế thừa UserDetailsService để xác thực User trong Database bên ngoài private final UserRepository userRepository; // Inject UserRepository để truy vấn User trong Database public CustomUserDetails(UserRepository userRepository) { this.userRepository = userRepository; } @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { // Phương thức xác thực User theo username. Mặc định khi gọi // authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password)) // sẽ gọi phương thức này loadUserByUsername(username) Users user = userRepository.findByUsername(username); // Tìm User trong Database theo username if (user == null) { // Nếu không tìm thấy User throw new UsernameNotFoundException("User not found"); // Ném ra ngoại lệ UsernameNotFoundException } return new MyUserPrincipal(user); // Trả về một đối tượng MyUserPrincipal với User tìm thấy } } // Custom UserDetails class MyUserPrincipal implements UserDetails { // Kế thừa UserDetails để tạo ra một UserDetails từ User private final Users user; // Inject Users để lấy thông tin User public MyUserPrincipal(Users user) { this.user = user; } @Override public Collection getAuthorities() { // Lấy danh sách các quyền của User (Role) return user.getRoles().stream() .map(role -> "ROLE_" + role) // Map role thành ROLE_role .map(SimpleGrantedAuthority::new) // Map thành SimpleGrantedAuthority .collect(Collectors.toList()); // Trả về danh sách các quyền của User // Có thể để rỗng, new ArrayList<>() nếu không sử dụng quyền } @Override public String getPassword() { return user.getPassword(); // Trả về mật khẩu của User } @Override public String getUsername() { return user.getUsername(); // Trả về username của User } } ``` ### 1.3.2.2. Cấu hình `Spring Security` để sử dụng `CustomUserDetailsService` Chúng ta cần cấu hình `Spring Security` để sử dụng `CustomUserDetailsService` thay vì `In-Memory` hoặc `Database` của chính ứng dụng. >SecurityConfig.java ```java package com.didan.authdb; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.core.Authentication; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.security.crypto.password.PasswordEncoder; @Configuration public class SecurityConfig { private final CustomUserDetails customUserDetails; // Inject CustomUserDetails để xác thực User trong Database bên ngoài vừa tạo public SecurityConfig(CustomUserDetails customUserDetails) { this.customUserDetails = customUserDetails; } // FilterChain,... @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } // Bean này trả về một đối tượng PasswordEncoder, dùng để mã hóa mật khẩu (password) @Bean // Bean này trả về một đối tượng AuthenticationManager, dùng để xác thực người dùng public AuthenticationManager authenticationManager(HttpSecurity http) throws Exception { AuthenticationManagerBuilder auth = http.getSharedObject(AuthenticationManagerBuilder.class); // Lấy ra một đối tượng AuthenticationManagerBuilder từ HttpSecurity auth.userDetailsService(customUserDetails).passwordEncoder(passwordEncoder()); // Cấu hình AuthenticationManagerBuilder để sử dụng CustomUserDetails và giải mã mật khẩu bằng passwordEncoder rồi so sánh với mật khẩu người dùng nhập vào return auth.build(); // Trả về một đối tượng AuthenticationManager } } ``` ### 1.3.2.3. Login từ `Database` bên ngoài (MYSQL) và sử dụng `AuthenticationManager` để xác thực >Congtroller.java ```java ... @PostMapping("/login") public ResponseEntity auth(@RequestBody Login login) { // Phương thức xác thực User từ Database bên ngoài Authentication authentication = authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(login.getUsername(), login.getPassword())); // sau khi gọi phương thức này, sẽ gọi phương thức loadUserByUsername(username) của CustomUserDetails để xác thực User từ Database bên ngoài return ResponseEntity.ok("User authenticated successfully"); } ``` ### 1.3.3. Thay đổi logic trong `API route` để xác thực từ `Request Body` thay vì `Basic Authentication` ```java @PostMapping("/login") public ResponseEntity auth(@RequestBody Login login) { Authentication auth = authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(login.getUsername(), login.getPassword())); // Xác thực người dùng từ database thay vì Basic Authentication (Sau khi đã Custom UserDetailsService) return new ResponseEntity<>(new ResponseToken(createToken(auth)), HttpStatus.ACCEPTED); // Trả về token sau khi xác thực } private String createToken(Authentication authentication) { JwtClaimsSet jwtClaimsSet = JwtClaimsSet.builder() .issuer("self") .issuedAt(Instant.now()) .expiresAt(Instant.now().plusSeconds(60 * 15)) .subject(authentication.getName()) .build(); JwtEncoderParameters jwtEncoderParameters = JwtEncoderParameters.from(jwtClaimsSet); return jwtEncoder.encode(jwtEncoderParameters).getTokenValue(); } record ResponseToken(String token) {}; ``` # 2. OAuth2 với Google ## 2.1. Giới thiệu - `OAuth2` là một giao thức cho phép ứng dụng yêu cầu quyền truy cập vào tài nguyên của người dùng từ một ứng dụng khác mà không cần biết mật khẩu của người dùng. ## 2.2. Cách thức hoạt động - `OAuth2` hoạt động theo các bước sau: - Bước 1: Ứng dụng yêu cầu quyền truy cập vào tài nguyên của người dùng thông qua một `Authorization Server`. - Bước 2: `Authorization Server` yêu cầu người dùng cung cấp thông tin đăng nhập. - Bước 3: Người dùng cung cấp thông tin đăng nhập. - Bước 4: `Authorization Server` cung cấp một mã `Authorization Code`. - Bước 5: Ứng dụng sử dụng mã `Authorization Code` để yêu cầu `Access Token`. - Bước 6: `Authorization Server` cung cấp `Access Token`. - Bước 7: Ứng dụng sử dụng `Access Token` để truy cập tài nguyên của người dùng. ## 2.3. Cấu hiện `OAuth2` với Google trong Spring Boot ### 2.3.1. Xác minh người dùng với Google Để xác minh người dùng với Google, chúng ta cần truy cập vào trang [Google Developers Console](https://console.developers.google.com/). > Lưu ý: Phần tạo Credentials, trong mục `Authorized redirect URIs` chúng ta cần thêm `http://localhost:8080/login/oauth2/code/google`. Với `http://localhost:8080` là địa chỉ của ứng dụng Spring Boot. prefix `/login/oauth2/code/google` là mặc định của Spring Security. ### 2.3.2. Thêm `client-id` và `client-secret` vào `application.properties` Sau khi tạo `Credentials` trên `Google Developers Console`, sẽ xuất hiện `client-id` và `client-secret`. Chúng ta cần thêm vào file `application.properties` như sau: ```properties spring.security.oauth2.client.registration.google.client-id=YOUR_CLIENT_ID spring.security.oauth2.client.registration.google.client-secret ``` ### 2.3.3. Thêm `OAuth2` dependency ```xml org.springframework.boot spring-boot-starter-oauth2-client ``` ### 2.3.4. Tắt `Basic Authentication`, `Form Login` và để `OAuth2` xử lý trong `Spring Security` >SecurityConfig.java ```java @Configuration public class SecurityConfig { @Bean public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { http .authorizeRequests(authorizeRequests -> authorizeRequests .anyRequest().authenticated() ) .formLogin(form -> form.disable()) // Tắt Form Login .httpBasic(httpBasic -> httpBasic.disable()) // Tắt Basic Authentication .oauth2Login(Customizer.withDefaults()); // Dùng OAuth2 xử lý return http.build(); } } ``` # 3. Sử dụng Interceptors trong Axios (Client) `Interceptors` trong `Axios` giúp chúng ta có thể thực hiện các thao tác trước hoặc sau khi gửi request. Điều này giúp chúng ta có thể thêm `header`, `token`, `log`, `loading`, `error handling`, `response handling`,... một cách dễ dàng. ## 3.1. Cài đặt Axios Để sử dụng `Interceptors` trong `Axios`, chúng ta cần cài đặt `Axios` vào ứng dụng React. Để cài đặt `Axios`, chúng ta chạy lệnh sau: ```bash npm install axios ``` ## 3.2. Sử dụng Interceptors Để sử dụng `Interceptors` trong `Axios`, chúng ta sử dụng `axios.interceptors`. Dưới đây là một số ví dụ về cách sử dụng `Interceptors`: >request.js ```typescript import axios, { ResponseType } from "axios"; export default function apiRequest( endpoint: string, method: string, // eslint-disable-next-line body: any | undefined = null, responseType: ResponseType | undefined = "json", ) { const headers = { // "Content-Type": [ // "application/json", // ], // Thêm các kiểu dữ liệu mà bạn muốn gửi lên server // Accept: [ // "application/json", // "text/plain", // "text/html", // "multipart/form-data", // "application/x-www-form-urlencoded", // ], // Thêm các kiểu dữ liệu mà bạn muốn nhận từ server "Access-Control-Allow-Origin": "*", // CORS }; const instance = axios.create({ headers }); // Tạo một instance axios với các headers mà bạn đã khai báo ở trên // Tạo 1 interceptor để xử lý với các request trước khi gửi lên server instance.interceptors.request.use( (config) => { const accessToken: string | null = localStorage.getItem("access_token"); // Lấy access token từ localStorage if (accessToken) { config.headers["Authorization"] = `Bearer ${accessToken}`; // Thêm access token vào header của request } return config; }, // Thêm vào header của request access token nếu có (error) => { return Promise.reject(error); // Xử lý khi có lỗi xảy ra khi gửi request lên server trả về 1 promise reject }, // Xử lý khi có lỗi xảy ra khi gửi request lên server ); // Tạo 1 interceptor để xử lý với các response trả về từ server instance.interceptors.response.use( (response) => { return response; // Trả về dữ liệu mà server trả về }, // Trả về dữ liệu mà server trả về nếu không có lỗi async (error) => { const originConfig = error.config; // Lấy ra config của request gây ra lỗi if (error.response && error.response.status === 419) { // Nếu có lỗi 419 (token hết hạn) thì thực hiện refresh token (lỗi 419 do backend tự định nghĩa trả về) try { const result = await axios.post( "http://localhost:8888/auth/refresh-token", {}, { headers: { "Content-Type": "application/json", Accept: "application/json", "Access-Control-Allow-Origin": "*", Authorization: `Bearer ${localStorage.getItem("refresh_token")}`, }, }, ); // Gửi request lên server để lấy access token và refresh token mới const { accessToken, refreshToken } = result.data; // Lấy ra access token và refresh token từ response localStorage.setItem("access_token", accessToken); // Lưu access token vào localStorage localStorage.setItem("refresh_token", refreshToken); // Lưu refresh token vào localStorage return instance(originConfig); // Thực hiện lại request gây ra lỗi với config ban đầu (request đã bị lỗi do token hết hạn) // eslint-disable-next-line } catch (err: any) { // Xử lý khi có lỗi xảy ra khi gửi request lên server trả về 1 promise reject if (err.response && err.response.status === 401) { // Nếu có lỗi 401 (unauthorized) thì refreshToken đã hết hạn, phải đăng nhập lại localStorage.removeItem("access_token"); localStorage.removeItem("refresh_token"); window.location.href = "/signin"; // Chuyển hướng đến trang signin } return Promise.reject(err); // Trả về lỗi nếu có lỗi xảy ra } } return Promise.reject(error); // Trả về lỗi nếu có lỗi xảy ra }, ); // Trả về kết quả của request với các interceptor đã được xử lý return instance.request({ method: method, // Phương thức gửi request url: endpoint, // Đường dẫn gửi request data: body, // Dữ liệu gửi lên server responseType: responseType, // Kiểu dữ liệu nhận từ server }); } ```

Spring: JWT, O2auth và cách thiết lập trong Spring Boot