AuthenticationAuthentication

người dùng hoạt động mỗi thángmonthly active users

500k

người dùng hoạt động mỗi thángmonthly active users

lượt refresh token lúc cao điểmtoken refreshes at peak

~300/s

lượt refresh token lúc cao điểmtoken refreshes at peak

thời hạn access tokenaccess token lifetime

15 phút

thời hạn access tokenaccess token lifetime

thời hạn tối đa của refresh tokenmaximum refresh token lifetime

30 ngày

thời hạn tối đa của refresh tokenmaximum refresh token lifetime

một lần bcrypt cost 12one bcrypt hash at cost 12

~250 ms

một lần bcrypt cost 12one bcrypt hash at cost 12

Trình duyệt chỉ nói chuyện với BFF. BFF giữ refresh token trong cookie HttpOnly, chuyển yêu cầu đăng nhập sang Auth Service hoặc sang nhà cung cấp OIDC. Order API kiểm tra chữ ký JWT bằng khoá công khai (JWKS). Bật “Access token hết hạn” để xem xoay vòng refresh token, bật “Refresh token bị đánh cắp” để xem phát hiện dùng lại.The browser only talks to the BFF. The BFF keeps the refresh token in an HttpOnly cookie and forwards sign-in to the auth service or to the OIDC provider. The Order API checks the JWT signature with the public keys (JWKS). Turn on “Access token expired” to see refresh rotation, and “Refresh token stolen” to see reuse detection.

1. 1

   Lưu mật khẩu an toànStoring passwords safely

   Dùng bcrypt (cost 12) hoặc argon2id (m=64 MB, t=3), mỗi mật khẩu có salt riêng sẵn trong hash. Không dùng SHA-256 thuần vì GPU thử hàng tỷ lần mỗi giây. Lưu chuỗi hash có cả thuật toán và tham số để nâng cost dần khi người dùng đăng nhập lại.Use bcrypt (cost 12) or argon2id (m=64 MB, t=3); each hash carries its own salt. Plain SHA-256 is wrong because a GPU tries billions per second. Store the full hash string with algorithm and parameters so you can raise the cost on the next successful login.

   Strategy
2. 2

   Dò mật khẩu và credential stuffingPassword guessing and credential stuffing

   Đếm lần sai trong Redis theo email (5 lần / 15 phút) và theo IP (20 lần / 15 phút). Quá ngưỡng thì trì hoãn tăng dần hoặc đòi CAPTCHA thay vì khoá cứng tài khoản, để kẻ xấu không khoá được người khác. Báo lỗi chung “Email hoặc mật khẩu không đúng” và vẫn chạy bcrypt với hash giả khi email không tồn tại để không lộ qua thời gian phản hồi.Count failures in Redis per email (5 per 15 minutes) and per IP (20 per 15 minutes). Past the limit add a growing delay or a CAPTCHA rather than a hard lock, so attackers cannot lock other people out. Return one generic “wrong email or password” message and still run bcrypt against a dummy hash when the email does not exist, so response time leaks nothing.

   Rate LimiterProxy
3. 3

   JWT không thu hồi đượcA JWT cannot be revoked

   JWT hợp lệ tới khi hết exp. Giữ access token ngắn (5–15 phút) và để refresh token, vốn có trạng thái trong DB, làm điểm thu hồi. Trường hợp khẩn cấp thì thêm deny list theo jti trong Redis với TTL bằng thời gian còn lại của token.A JWT stays valid until exp. Keep access tokens short (5–15 minutes) and let the refresh token, which has state in the DB, be the revocation point. For emergencies add a deny list by jti in Redis with a TTL equal to the token's remaining life.

   Proxy
4. 4

   Refresh token bị đánh cắpA stolen refresh token

   Xoay vòng mỗi lần dùng: token cũ chuyển ROTATED, token mới cùng family. Token ROTATED mà xuất hiện lại thì thu hồi cả family và báo người dùng. Chỉ lưu SHA-256 của token để lộ DB không lộ token.Rotate on every use: the old token becomes ROTATED and the new one joins the same family. If a ROTATED token shows up again, revoke the family and warn the user. Store only the SHA-256 of the token so a leaked DB does not leak tokens.

   Observer
5. 5

   Token trong trình duyệt bị XSS đọcXSS reading tokens in the browser

   Không để refresh token trong localStorage. BFF giữ nó trong cookie HttpOnly, Secure, SameSite=Strict, Path=/auth/refresh, kèm CSRF token cho các yêu cầu đổi trạng thái. Access token chỉ ở bộ nhớ của tab.Never put the refresh token in localStorage. The BFF keeps it in an HttpOnly, Secure, SameSite=Strict cookie with Path=/auth/refresh, plus a CSRF token for state-changing requests. The access token lives only in the tab's memory.

   Proxy
6. 6

   Kiểm tra xác thực ở mọi APIChecking authentication on every API

   Một chuỗi filter: lấy Bearer token → kiểm tra chữ ký với JWKS (cache theo kid) → kiểm tra iss, aud, exp → nạp quyền vào context. Spring Security SecurityFilterChain hay middleware Go đều là Chain of Responsibility; logging và metric bọc ngoài như decorator.A chain of filters: extract the Bearer token → verify the signature against the JWKS (cached by kid) → check iss, aud, exp → put the principal in the context. Spring Security's SecurityFilterChain and Go middleware are both a Chain of Responsibility; logging and metrics wrap it as decorators.

   Chain of ResponsibilityDecorator
7. 7

   Đăng nhập qua Google hay KeycloakSigning in with Google or Keycloak

   Dùng Authorization Code + PKCE. BFF là confidential client: đổi code lấy token ở phía server, kiểm tra state, nonce và chữ ký id_token, rồi phát phiên riêng của hệ thống. Trình duyệt không bao giờ thấy token của IdP. Mỗi IdP là một strategy cấu hình riêng.Use the Authorization Code flow with PKCE. The BFF is a confidential client: it exchanges the code server-side, checks state, nonce and the id_token signature, then issues the system's own session. The browser never sees the IdP's tokens. Each IdP is a separately configured strategy.

   StrategyProxy

Xoay vòng refresh token có phát hiện dùng lại. Điểm khó: khi phát hiện dùng lại, việc thu hồi phải được commit dù hàm trả lỗi cho client.Refresh token rotation with reuse detection. The tricky part: when reuse is detected, the revocation must commit even though the call returns an error to the client.

@Service
@RequiredArgsConstructor
public class RefreshTokenService {
    private static final Duration ACCESS_TTL = Duration.ofMinutes(15);
    private static final Duration REFRESH_TTL = Duration.ofDays(30);
    private final RefreshTokenRepository repo;
    private final JwtIssuer jwt;
    private final ApplicationEventPublisher events;
    private final SecureRandom random = new SecureRandom();

    @Transactional(noRollbackFor = InvalidTokenException.class)1
    public TokenPair rotate(String raw) {
        RefreshToken old = repo.findByHashForUpdate(sha256(raw))2
                .orElseThrow(InvalidTokenException::new);
        if (old.getStatus() != Status.ACTIVE) {3
            repo.revokeFamily(old.getFamilyId(), "reuse");
            events.publishEvent(new TokenReuseDetected(old.getUserId(), old.getFamilyId()));
            throw new InvalidTokenException();
        }
        if (old.getExpiresAt().isBefore(Instant.now())) throw new InvalidTokenException();

        old.setStatus(Status.ROTATED);
        String next = newToken();
        repo.save(RefreshToken.childOf(old, sha256(next), Instant.now().plus(REFRESH_TTL)));
        return new TokenPair(jwt.issue(old.getUserId(), ACCESS_TTL), next);
    }

    private String newToken() {
        byte[] b = new byte[32];
        random.nextBytes(b);4
        return Base64.getUrlEncoder().withoutPadding().encodeToString(b);
    }
}

type RefreshService struct {
	tx     TxRunner
	jwt    JWTIssuer
	events Publisher
}

func (s *RefreshService) Rotate(ctx context.Context, raw string) (TokenPair, error) {
	var pair TokenPair
	var reused *RefreshToken
	err := s.tx.Do(ctx, func(tx Tx) error {
		old, err := tx.LockRefreshByHash(ctx, sha256Hex(raw)) // FOR UPDATE1
		if err != nil {
			return ErrInvalidToken
		}
		if old.Status != StatusActive {
			reused = old
			return tx.RevokeFamily(ctx, old.FamilyID, "reuse") // nil → commit2
		}
		if time.Now().After(old.ExpiresAt) {
			return ErrInvalidToken
		}
		next, err := newToken()
		if err != nil {
			return err
		}
		if err := tx.MarkRotated(ctx, old.ID); err != nil {
			return err
		}
		child := old.Child(sha256Hex(next), time.Now().Add(30*24*time.Hour))
		if err := tx.InsertRefresh(ctx, child); err != nil {
			return err
		}
		access, err := s.jwt.Issue(old.UserID, 15*time.Minute)
		pair = TokenPair{Access: access, Refresh: next}
		return err
	})
	if err != nil {
		return TokenPair{}, err
	}
	if reused != nil {
		s.events.Publish(ctx, TokenReuseDetected{UserID: reused.UserID, FamilyID: reused.FamilyID})3
		return TokenPair{}, ErrInvalidToken
	}
	return pair, nil
}

func newToken() (string, error) {
	b := make([]byte, 32)
	if _, err := rand.Read(b); err != nil { // crypto/rand4
		return "", err
	}
	return base64.RawURLEncoding.EncodeToString(b), nil
}

Mỗi pattern mở bài học tương ứng trong menu Pattern.Each one opens its lesson in the Patterns menu.