Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

SecuritySenior16 phút đọc

Refresh token xoay vòng và phân quyền theo permission trong Spring Security

Ôn 14 thẻ
Trong bài này

Cụm bài Spring Security cho REST API: 1. JWT với resource server · 2. Refresh token và phân quyền

Access token 15 phút thì người dùng cần cách lấy token mới mà không đăng nhập lại, và cần cách đăng xuất thật sự. Bài này cài refresh token xoay vòng trên Spring Boot 4, rồi cài phân quyền theo permission lưu trong database. Lý thuyết xoay vòng ở bài xác thực, lý thuyết RBAC và schema ở bài phân quyền; ở đây là code đã chạy test.

1. Thiết kế refresh token trong database

Ý chính: refresh token phải thu hồi được, nên nó là bản ghi trong DB. Lưu hash chứ không lưu chuỗi gốc, gắn familyId để biết các token sinh ra từ cùng một lần đăng nhập.

@Entity
@Table(name = "refresh_tokens", indexes = @Index(name = "ix_refresh_family", columnList = "family_id"))
public class RefreshToken {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
    /** SHA-256 của token gốc: lộ DB không lộ token dùng được. */
    @Column(name = "token_hash", nullable = false, unique = true, length = 64) private String tokenHash;
    /** Mọi token xoay vòng từ một lần đăng nhập chung một family. */
    @Column(name = "family_id", nullable = false, length = 36) private String familyId;
    @ManyToOne(fetch = FetchType.LAZY, optional = false) @JoinColumn(name = "user_id") private User user;
    @Column(nullable = false) private Instant expiresAt;
    private Instant revokedAt;
    // ...
}
  • Opaque, không JWT: refresh token chỉ server đọc, nên không cần claim. Chuỗi ngẫu nhiên ngắn hơn, không lộ gì, và không có cám dỗ “kiểm chữ ký là đủ, khỏi tra DB”.
  • Hash bằng SHA-256, không BCrypt: token đã có 256 bit ngẫu nhiên, không đoán được như mật khẩu, nên hash nhanh là đủ và tra được bằng index unique.
  • familyId = một phiên trên một thiết bị. Đăng xuất một thiết bị là thu hồi một family.

2. Xoay vòng có phát hiện dùng lại

Ý chính: token hợp lệ thì thu hồi nó và phát token kế tiếp cùng family. Token đã thu hồi mà xuất hiện lại nghĩa là có hai người cầm cùng một token, nên thu hồi cả family và trả 401.

sequenceDiagram
  participant U as Người dùng
  participant A as Kẻ trộm
  participant API
  U->>API: refresh với R1
  API-->>U: R2 (R1 bị thu hồi)
  A->>API: refresh với R1 đã đánh cắp
  API-->>A: 401, thu hồi cả family
  U->>API: refresh với R2
  API-->>U: 401, phải đăng nhập lại
@Transactional(noRollbackFor = InvalidRefreshTokenException.class)
public Rotated rotate(String rawToken) {
    Instant now = clock.instant();
    RefreshToken current = tokens.findByTokenHash(sha256(rawToken))   // SELECT ... FOR UPDATE
            .orElseThrow(() -> new InvalidRefreshTokenException("unknown refresh token"));
    if (current.isRevoked()) {
        int n = tokens.revokeFamily(current.getFamilyId(), now);
        log.warn("Refresh token reuse detected, family={} revoked={} user={}",
                current.getFamilyId(), n, current.getUser().getId());
        throw new InvalidRefreshTokenException("refresh token reuse detected");
    }
    if (!current.getExpiresAt().isAfter(now)) throw new InvalidRefreshTokenException("refresh token expired");
    current.revoke(now);
    User user = current.getUser();
    String next = issueInFamily(user, current.getFamilyId());
    var roles = user.getRoles().stream().map(r -> r.getName()).sorted().toList();
    return new Rotated(user.getEmail(), roles, next);
}

Ba chi tiết nhỏ quyết định đúng sai:

  • @Lock(PESSIMISTIC_WRITE) trên findByTokenHash: hai tab cùng refresh một lúc thì request thứ hai chờ, rồi thấy token đã thu hồi. Không khoá thì cả hai cùng nhận token mới, và family có hai nhánh.
  • noRollbackFor: phát hiện dùng lại thì ném exception để trả 401. Mặc định @Transactional rollback khi gặp RuntimeException, tức là huỷ luôn câu UPDATE thu hồi family. Test trong lab khẳng định family đã bị thu hồi sau 401.
  • Clock được inject: test dời thời gian được, không phải Thread.sleep.

Ý chính: refresh token đi trong cookie HttpOnly có Path hẹp; access token đi trong body. Logout thu hồi family của thiết bị này và xoá cookie bằng Max-Age=0.

private static ResponseCookie cookie(String value, long maxAgeSeconds) {
    return ResponseCookie.from("refresh_token", value)
            .httpOnly(true).secure(true).sameSite("Strict")
            .path("/api/v1/auth")      // trình duyệt chỉ gửi tới refresh/logout, không kèm mọi API call
            .maxAge(maxAgeSeconds).build();
}

@PostMapping("/refresh")
public ResponseEntity<ApiResponse<TokenResponse>> refresh(
        @CookieValue(name = COOKIE, required = false) String cookie) {
    if (cookie == null) throw new InvalidRefreshTokenException("missing refresh token");
    RefreshTokenService.Rotated r = refreshTokens.rotate(cookie);
    // roles đọc lại từ DB mỗi lần refresh: đổi role có hiệu lực trong một vòng đời access token
    return withTokens(jwtService.issueAccessToken(r.email(), r.roles()), r.rawToken());
}

@PostMapping("/logout")
public ResponseEntity<Void> logout(@CookieValue(name = COOKIE, required = false) String cookie) {
    if (cookie != null) refreshTokens.revoke(cookie);
    return ResponseEntity.noContent().header(HttpHeaders.SET_COOKIE, cookie("", 0).toString()).build();
}
  • SameSite=Strict cộng Path hẹp là thứ thay CSRF token cho endpoint dùng cookie. Frontend ở site khác hẳn (khác eTLD+1) thì Strict không gửi cookie; khi đó cần None + CSRF token hoặc kiểm Origin.
  • Handler InvalidRefreshTokenException trả 401 và xoá cookie, để client không lặp vô hạn với token chết.
  • Access token đã phát vẫn sống tới khi hết 15 phút sau logout. Muốn cắt ngay thì cần danh sách chặn theo jti hoặc “token version” theo user (các cách thu hồi JWT).

4. Dọn token hết hạn

Ý chính: token hết hạn và đã thu hồi vẫn nằm trong bảng; một job hằng đêm xoá chúng bằng một câu DELETE. Chạy nhiều instance thì phải khoá để chỉ một máy chạy.

@Scheduled(cron = "0 0 2 * * *")   // 02:00 theo múi giờ server
@Transactional
public void purgeExpired() {
    int deleted = tokens.deleteExpiredBefore(clock.instant());
    log.info("Purged {} expired refresh tokens", deleted);
}

Cần @EnableScheduling trên class ứng dụng. Ba việc senior thêm vào: ShedLock (hoặc khoá DB) khi có nhiều instance, ghi rõ zone cho cron, và xoá theo lô khi bảng lớn để không khoá lâu. Đã viết kỹ ở cron job và xoá dữ liệu cũ an toàn.

5. Role, authority và permission trong Spring

Ý chính: Spring chỉ có một khái niệm là GrantedAuthority (một chuỗi). Role là authority có tiền tố ROLE_; permission là authority bạn tự đặt tên, hoặc như lab, là quy tắc (method, path) lưu trong DB.

Bạn viết Spring lưu / so sánh
.roles("ADMIN") authority ROLE_ADMIN
hasRole('ADMIN') so với ROLE_ADMIN
.authorities("CREATE_USER") authority CREATE_USER
hasAuthority('CREATE_USER') so khớp chính xác chuỗi

Hai chỗ đặt quy tắc:

  • Quy tắc URL trong authorizeHttpRequests: thô, tập trung một chỗ, chạy trước controller.
  • Method security với @EnableMethodSecurity + @PreAuthorize: gần nghiệp vụ, đọc được tham số (#id), chạy trong proxy của bean.

6. Permission trong DB với AuthorizationManager tự viết

Ý chính: mỗi permission là (method, path pattern), gắn vào role qua bảng permission_role. Một AuthorizationManager lấy role trong token, nạp permission của các role đó bằng một câu JOIN, rồi so với request.

@Override
public AuthorizationResult authorize(Supplier<? extends Authentication> authentication,
                                     RequestAuthorizationContext ctx) {
    Authentication auth = authentication.get();
    if (auth == null || !auth.isAuthenticated()) return new AuthorizationDecision(false);
    List<String> roleNames = auth.getAuthorities().stream()
            .map(GrantedAuthority::getAuthority)
            .filter(a -> a.startsWith("ROLE_")).map(a -> a.substring(5)).toList();
    if (roleNames.isEmpty()) return new AuthorizationDecision(false);

    String method = ctx.getRequest().getMethod();
    PathContainer path = PathContainer.parsePath(ctx.getRequest().getRequestURI());
    boolean granted = permissions.findByRoleNames(roleNames).stream()
            .anyMatch(p -> p.getMethod().equalsIgnoreCase(method)
                    && PathPatternParser.defaultInstance.parse(p.getApiPath()).matches(path));
    return new AuthorizationDecision(granted);
}
@Query("select distinct p from Role r join r.permissions p where r.name in :roleNames")
List<Permission> findByRoleNames(Collection<String> roleNames);
  • Path pattern, không so chuỗi: permission lưu /api/v1/users/{id}, request là /api/v1/users/42. PathPatternParser khớp giống cách Spring MVC map controller.
  • Gắn vào chain: .requestMatchers("/api/v1/**").access(permissionCheck).
  • Đổi quyền của role chỉ là sửa dữ liệu, không deploy lại, và có hiệu lực ngay vì tra mỗi request.
Many-to-many Role–Permission: thay toàn bộ, Set và phía sở hữu

API PUT /roles/{id} nhận permissionIds và thay toàn bộ danh sách (không cộng dồn):

@Transactional
public Role replacePermissions(Long roleId, Set<Long> permissionIds) {
    Role role = roles.findWithPermissionsById(roleId)
            .orElseThrow(() -> new ResourceNotFoundException("Role", "id", roleId));
    role.replacePermissions(loadAll(permissionIds));   // clear() rồi addAll()
    return role;                                        // dirty checking ghi phần chênh lệch lúc commit
}

Set<Permission> loadAll(Set<Long> ids) {
    List<Permission> found = permissions.findAllById(ids);
    if (found.size() != ids.size()) {                  // findAllById lặng lẽ bỏ qua id không tồn tại
        // ... ném ResourceNotFoundException với id thiếu đầu tiên
    }
    return new HashSet<>(found);
}
  • Set, không List: với List không có thứ tự (bag), Hibernate xoá hết dòng join của role rồi insert lại khi bỏ một phần tử.
  • Không CascadeType.REMOVE trên @ManyToMany: xoá một role không được xoá permission dùng chung.
  • Phía sở hữu (owning side) là bên có @JoinTable. Xoá từ phía sở hữu thì Hibernate xoá dòng join trước. Tài liệu gốc nói “DELETE role → JPA tự clear join table (cascade)”: chỉ đúng vì Role sở hữu permission_role, và đó không phải cascade. Với user_role do User sở hữu, xoá một Role đang được gán sẽ lỗi khoá ngoại, trừ khi gỡ role khỏi các user trước hoặc chặn xoá role đang dùng.
  • @DataJpaTest của lab khẳng định sau khi thay, permission cũ vẫn còn trong bảng, chỉ mất liên kết; và gọi em.flush(); em.clear() để test SQL thật chứ không chỉ cache cấp 1.

7. Hai lớp: quyền URL và @PreAuthorize

Ý chính: quyền URL trả lời “role này có được gọi endpoint này không”; @PreAuthorize và service trả lời những luật URL không diễn đạt được. Lab đòi cả ba cho DELETE /users/{id}.

@DeleteMapping("/{id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<Void> delete(@PathVariable Long id, Authentication auth) {
    userService.delete(id, auth.getName());   // service từ chối tự xoá chính mình
    return ResponseEntity.noContent().build();
}
  • Role HR có permission DELETE /api/v1/users/{id} nhưng không phải ADMIN → qua filter, bị @PreAuthorize chặn → 403.
  • ADMIN có permission → 204; ADMIN xoá chính mình → 400 do luật nghiệp vụ trong service.
  • Luật kiểu “chỉ xoá user cùng công ty” hay “không xoá SUPER_ADMIN” thuộc service, vì cần dữ liệu. Đây đúng là thứ AI sinh code hay bỏ sót.
@ExceptionHandler(org.springframework.security.access.AccessDeniedException.class)
void accessDenied(org.springframework.security.access.AccessDeniedException ex) {
    throw ex;   // để security trả 403, không rơi xuống catch-all 500
}

8. Test: chứng minh luồng chạy đúng

Ý chính: luồng bảo mật phải có test tích hợp chạy cả filter chain thật: 200 khi có quyền, 403 khi không, 401 khi token cũ bị dùng lại. Lab dùng @SpringBootTest + MockMvc và một TestDataFactory tạo user với đúng permission cần.

@Test
void reusingARotatedTokenRevokesTheWholeFamily() throws Exception {
    String first = login();
    String second = mvc.perform(post("/api/v1/auth/refresh").cookie(new Cookie("refresh_token", first)))
            .andReturn().getResponse().getCookie("refresh_token").getValue();

    mvc.perform(post("/api/v1/auth/refresh").cookie(new Cookie("refresh_token", first)))   // kẻ trộm dùng lại
       .andExpect(status().isUnauthorized())
       .andExpect(jsonPath("$.detail").value("refresh token reuse detected"));

    mvc.perform(post("/api/v1/auth/refresh").cookie(new Cookie("refresh_token", second)))  // token mới nhất cũng chết
       .andExpect(status().isUnauthorized());
    assertThat(tokens.findAll()).allMatch(RefreshToken::isRevoked);
}
Các test còn lại: 403 và 200, logout
@Test
void roleWithoutPermissionIs403() throws Exception {
    User viewer = data.user("viewer@example.dev", "secret-pass-1", "VIEWER");   // role không có permission
    mvc.perform(get("/api/v1/users/" + admin.getId())
            .header("Authorization", "Bearer " + data.accessToken(viewer, "VIEWER")))
       .andExpect(status().isForbidden())
       .andExpect(jsonPath("$.status").value(403));
}

@Test
void permissionMatchingPathPatternIs200() throws Exception {
    mvc.perform(get("/api/v1/users/" + admin.getId())
            .header("Authorization", "Bearer " + data.accessToken(admin, "ADMIN")))
       .andExpect(status().isOk())
       .andExpect(jsonPath("$.data.email").value("admin@example.dev"));
}

@Test
void logoutRevokesAndClearsCookie() throws Exception {
    String refresh = login();
    mvc.perform(post("/api/v1/auth/logout").cookie(new Cookie("refresh_token", refresh))
            .header("Authorization", "Bearer " + data.accessToken(admin, "ADMIN")))
       .andExpect(status().isNoContent())
       .andExpect(header().string("Set-Cookie", containsString("Max-Age=0")));
    mvc.perform(post("/api/v1/auth/refresh").cookie(new Cookie("refresh_token", refresh)))
       .andExpect(status().isUnauthorized());
}

TestDataFactory.user(email, password, role, "GET /api/v1/users/{id}", ...) tạo permission, role, user và phát JWT thật cho user đó. Test không dùng @Transactional: muốn commit thật như production, để thấy cả lỗi lazy load và việc noRollbackFor có tác dụng. Mỗi test gọi data.reset() ở @BeforeEach.

Kết quả chạy (JDK 21, Spring Boot 4.0.3, H2): mvn test 29 test, 28 qua, 1 bỏ qua (test Testcontainers, máy không chạy được Docker). Gồm 4 test xoay vòng/logout, 3 test 401/403/200, 2 test method security. Chưa đo hiệu năng của việc tra permission mỗi request, và chưa chạy trên MySQL/PostgreSQL thật.

Ghi nhớ

  • Giải thích được vì sao refresh token là chuỗi ngẫu nhiên lưu dạng hash, không phải JWT.
  • Vẽ được luồng reuse detection và chỉ ra hai chi tiết code làm nó đúng (khoá dòng, noRollbackFor).
  • Biết vì sao LazyInitializationException xuất hiện sau service @Transactional và cách sửa đúng.
  • Phân biệt được role, authority, permission trong Spring và chỗ đặt mỗi loại quy tắc.
  • Biết cái giá của việc tra permission trong DB mỗi request và cách cache có thu hồi.

Câu hỏi phỏng vấn

Junior

Vì sao cần refresh token khi đã có access token?

Để access token sống ngắn (vài phút) mà người dùng không phải đăng nhập lại liên tục, và để server có chỗ thu hồi phiên.

Access token kiểm không cần DB nên không thu hồi được; refresh token nằm trong DB nên logout hay chặn tài khoản có hiệu lực ở lần refresh kế tiếp.

hasRole(‘ADMIN’) và hasAuthority(‘ADMIN’) khác nhau thế nào?

hasRole('ADMIN') so với authority ROLE_ADMIN; hasAuthority('ADMIN') so khớp chính xác chuỗi ADMIN.

Role chỉ là authority có tiền tố ROLE_. Trộn hai cách là nguồn lỗi 403 khó hiểu hay gặp.

Mid

Vì sao lưu hash của refresh token, và vì sao SHA-256 mà không phải BCrypt?

Lưu hash để lộ DB không lộ token dùng được; SHA-256 là đủ vì token có 256 bit ngẫu nhiên, không đoán được như mật khẩu.

BCrypt chậm để chống đoán mật khẩu yếu; với token ngẫu nhiên thì không cần, và hash xác định (deterministic) cho phép tra bằng index unique.

Service @Transactional trả về entity, controller gọi getRoles() thì lỗi LazyInitializationException. Vì sao và sửa thế nào?

Vì collection lazy chỉ nạp được khi session Hibernate còn mở, mà session đóng cùng transaction; open-in-view tắt nên controller không có session.

Sửa bằng cách lấy dữ liệu cần (DTO/record) bên trong transaction, hoặc fetch join/entity graph. Không sửa bằng bật open-in-view hay EAGER.

Vì sao @ExceptionHandler(Exception.class) có thể làm người thiếu quyền nhận 500?

Vì @PreAuthorize ném AccessDeniedException trong lúc gọi controller, advice bắt nó trước security, và handler catch-all trả 500.

Thêm handler riêng cho AccessDeniedException (ném lại hoặc trả 403), và có test cho trường hợp thiếu quyền.

Senior

Thiết kế refresh token xoay vòng có phát hiện dùng lại. Những chỗ nào dễ sai khi cài?

Mỗi lần refresh thu hồi token cũ và phát token mới cùng family; token đã thu hồi xuất hiện lại thì thu hồi cả family. Dễ sai ở concurrency, transaction và trải nghiệm người dùng.

  • Hai refresh song song: khoá dòng hoặc update có điều kiện, nếu không family rẽ nhánh.
  • Ném exception sau khi thu hồi family: phải noRollbackFor, nếu không việc thu hồi bị rollback.
  • Response bị mất: cân nhắc grace period ngắn, và client chỉ refresh một luồng.
  • Log cảnh báo reuse để điều tra.
Bạn kiểm permission (method, path) trong DB mỗi request. Trên production sẽ thay đổi gì?

Cache role → permission (in-process hoặc Redis) và xoá cache khi sửa quyền, kèm đo latency; vẫn không đưa permission vào JWT.

Biên dịch sẵn path pattern thay vì parse mỗi request. Ghi rõ độ trễ chấp nhận được khi đổi quyền. Giữ quy tắc nghiệp vụ theo dữ liệu (cùng công ty, sở hữu bản ghi) ở service, vì URL không diễn đạt được.

Xoá một Role đang được gán cho user thì chuyện gì xảy ra với JPA many-to-many?

Phụ thuộc phía sở hữu: nếu User sở hữu bảng user_role, xoá Role sẽ lỗi khoá ngoại; Hibernate chỉ tự xoá dòng join khi xoá từ phía sở hữu.

Phải gỡ role khỏi các user trước (trong cùng transaction) hoặc chặn xoá role đang dùng bằng một lỗi 409 rõ ràng. Không dùng CascadeType.REMOVE trên many-to-many.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
refresh token rotation /rɪˈfreʃ ˈtoʊ.kən roʊˈteɪ.ʃən/ xoay vòng refresh token “With rotation, every refresh token can be used exactly once.”
reuse detection /riːˈjuːs dɪˈtek.ʃən/ phát hiện dùng lại “Reuse detection revokes the whole family when an old token comes back.”
token family /ˈtoʊ.kən ˈfæm.əl.i/ chuỗi token của một phiên “Each login starts a new token family, one per device.”
opaque token /oʊˈpeɪk ˈtoʊ.kən/ token không mang nội dung “The refresh token is opaque, so only the server can interpret it.”
revoke /rɪˈvoʊk/ thu hồi “Logout revokes the family and clears the cookie.”
row lock /roʊ lɑːk/ khoá dòng “A row lock serializes two parallel refreshes with the same token.”
method security /ˈmeθ.əd sɪˈkjʊr.ə.ti/ phân quyền trên method “Method security covers rules the URL can’t express.”
owning side /ˈoʊ.nɪŋ saɪd/ phía sở hữu quan hệ “Only the owning side of a many-to-many writes the join table.”
lazy loading /ˈleɪ.zi ˈloʊ.dɪŋ/ nạp trễ “Lazy loading outside the transaction throws LazyInitializationException.”
cache eviction /kæʃ ɪˈvɪk.ʃən/ xoá cache “We evict the permission cache whenever a role changes.”

Ghi chép dựa trên tài liệu khoá học của Hỏi Dân IT, viết lại và bổ sung theo cách hiểu của mình.