Thử hình dung một refresh token rơi vào chỗ không nên rơi: một file HAR đính kèm bug report, một dòng log của proxy bật chế độ verbose, một profile trình duyệt bị malware chép đi. Không ai để ý. Người dùng vẫn làm việc bình thường, và kẻ đang giữ bản sao cũng vậy. Cứ vài phút, cả hai lại đem đúng chuỗi byte đó đổi lấy access token mới, còn server thì không phân biệt được ai với ai, vì chẳng có gì để phân biệt cả. Chỉ có một token.
Refresh token rotation và reuse detection (phát hiện token bị dùng lại) sinh ra để giải đúng bài toán này. Dưới đây là cách auth service của một nền tảng mười ba service NestJS làm việc đó, đọc thẳng từ repository: mỗi lần đăng nhập là một dòng trong database, mỗi lần refresh là một câu UPDATE có điều kiện, và một quy tắc biến token bị phát lại thành chuông báo động. Kèm theo là những chỗ thiết kế này vẫn còn hở.
Vì sao lộ refresh token nguy hiểm hơn lộ access token?
Vì mỗi loại sinh ra cho một việc khác nhau.
Access token được đưa cho mọi service ở mọi request, nên nó được thiết kế để mất cũng chẳng đáng bao nhiêu: ở đây nó là một JWT mặc định hết hạn sau 15 phút (cấu hình được tối đa một giờ). Trộm được một cái thì có mười lăm phút.
Refresh token chỉ được đưa cho đúng một endpoint, và việc duy nhất của nó là xin access token mới. Trộm được nó là nắm luôn cả phiên đăng nhập, chừng nào refresh token còn sống. Trong repository, thời hạn refresh là idle timeout: mặc định 30 phút, cấu hình được tới 90 ngày. Bản deploy nào nâng con số này lên cho tính năng "ghi nhớ đăng nhập" thì một token bị chép là nhiều tháng truy cập.
Mà dùng nó thì trông hoàn toàn bình thường. Không gõ mật khẩu, không kích hoạt cảnh báo đăng nhập nào: kẻ trộm gọi đúng cái endpoint mà trình duyệt của người dùng vẫn gọi.
Sao phải dùng hai token với hai thời hạn khác nhau?
Đây là phép so sánh tôi sẽ dùng xuyên suốt bài: hệ thống tàu điện với vé dùng một lần.
Access token là tấm phiếu đã đóng dấu mà bạn chìa cho nhân viên soát vé trên tàu. Sống ngắn, ai cũng được xem, mất cũng không sao.
Refresh token là tấm vé bạn nhét vào một cửa soát duy nhất để lấy phiếu mới. Bạn không bao giờ đưa nó cho người soát vé. Trên trình duyệt, điều này đúng theo nghĩa đen: cookie bị giới hạn path vào các route auth, nên nó không bao giờ được gửi đi chỗ khác.
Hai token cho phép dồn rủi ro bị lộ vào cái rẻ tiền, còn thời hạn dài thì đặt vào cái được canh giữ kỹ.
Access token ở đây có thật sự stateless không?
Không. Access token mang claim session id tên là sid. Khi xác thực một request, auth service kiểm tra chữ ký JWT rồi nạp dòng session theo sid. Token bị từ chối nếu session đã bị revoke hoặc hết hạn, tài khoản bị khóa hay vô hiệu hóa, hoặc role của người dùng đã đổi sau lúc cấp token. Không service nào khác tự verify JWT; service nào cần xác thực người dùng thì hỏi auth service qua gRPC, có deadline cho lời gọi (bài REST, gRPC hay Kafka giải thích vì sao điều đó quan trọng).
Nghĩa là revoke một session sẽ chặn access token của nó ngay từ request kế tiếp, chứ không phải đợi 15 phút. Reuse detection dựa vào chính điều này.
Refresh token rotation là gì?
Bắt đầu từ phiên bản mà phần lớn tutorial vẫn dạy. Refresh token là một chuỗi ngẫu nhiên dài lưu trên dòng user, còn hạn thì còn dùng. Mỗi lần refresh trả về access token mới và giữ nguyên refresh token cũ.
Theo phép so sánh tàu điện, đó là tấm vé mà cửa soát đọc xong lại trả cho bạn. Ai photo được nó thì đi tàu được chừng nào bản gốc còn dùng được.
Rotation đổi đúng một luật: cửa soát giữ vé của bạn lại và in cho bạn vé mới. Mỗi lần refresh thành công, token vừa nộp bị vô hiệu và một token mới được trả về. Bản sao bị trộm giờ chỉ dùng được đến lần kế tiếp một trong hai bên dùng nó.
Vì sao chỉ rotation thôi là chưa đủ?
Cái bẫy nằm ở đây. Giả sử cửa soát chỉ nhớ tấm vé hiện tại:
// Cách xoay sai: đọc, kiểm tra, rồi mới ghi.
const session = await db.session.findUnique({ where: { tokenHash: presentedHash } });
if (!session || session.revokedAt || session.expiresAt <= now) {
throw new UnauthorizedException();
}
await db.session.update({
where: { id: session.id },
data: { tokenHash: nextHash },
});Thử diễn lại một vụ trộm. Kẻ trộm refresh trước, nên vé của người dùng giờ không khớp với gì nữa. Lần refresh tiếp theo của người dùng báo "invalid", họ đăng nhập lại và nhận một session mới. Kẻ trộm vẫn giữ session cũ.
Vậy rotation mà không có trí nhớ thì chẳng phát hiện được gì. Nó chỉ chọn ra người thắng, và người thắng là ai refresh trước. Người thua nhận đúng cái lỗi chung chung y như khi token hết hạn bình thường.
Còn bug thứ hai: đoạn code đọc rồi mới ghi. Hai request mang cùng một token có thể cùng lọt qua bước kiểm tra trước khi bên nào kịp ghi, và cả hai đều nhận response trông như hợp lệ. Bạn vừa tách đôi một session mà bạn tưởng chỉ có một nhánh.
Reuse detection bắt token bị trộm bằng cách nào?
Cho cửa soát nhớ đúng một thứ: tấm vé cuối cùng nó vừa nuốt.
Mỗi dòng session lưu hai hash: tokenHash là token hiện tại, và previousTokenHash là token vừa bị xoay ra. Token được nộp lên giờ chỉ rơi vào một trong ba trường hợp:
| Token nộp lên khớp với | Ý nghĩa | Phản hồi |
|---|---|---|
tokenHash |
bình thường | xoay, trả token mới |
previousTokenHash |
vé đã dùng bị phát lại | revoke session, 401 |
| không khớp gì | lạ hoặc quá cũ | 401, không làm gì thêm |
Diễn lại vụ trộm, lần này với trí nhớ đó. Kẻ trộm refresh trước và nhận vé mới. Lần refresh tiếp theo của người dùng nộp lên đúng cái giờ đang nằm ở previousTokenHash. Một tấm vé đã bị nuốt mà lại xuất hiện nghĩa là có hai người đang giữ bản sao, và server không có cách nào biết ai là người ngay. Nên nó không đoán: nó revoke cả session. Người dùng phải đăng nhập lại, và lần này kẻ trộm cũng bị khóa ngoài, vì token mới toanh của hắn thuộc về một session đã bị revoke. Đảo thứ tự thì kết quả vẫn y vậy: ai đến sau sẽ là người giật chuông.
Đó là ý cốt lõi: vụ trộm lộ ra ngay khi cả hai bản sao đều được dùng.
Sao phải revoke cả session chứ không chỉ token?
Vì không phân biệt được ai là ai. Chỉ từ chối token bị phát lại tức là bạn vừa công nhận người đến trước, mà người đó có thể chính là kẻ trộm. Revoke session là phản ứng duy nhất đúng với cả hai thứ tự, và vì access token luôn được đối chiếu với dòng session, nó chặn luôn access token mà kẻ trộm đang cầm. Mỗi lần đăng nhập là một dòng, nên việc này chỉ kết thúc session của thiết bị đó, không đụng tới các session khác của người dùng.
Xoay token thế nào cho an toàn khi có request đồng thời?
Giờ sửa race condition. Rotation phải là một phép compare-and-swap: chỉ thay hash nếu nó vẫn đúng là cái tôi được đưa. Viết bằng SQL:
UPDATE refresh_session
SET token_hash = $2, -- hash mới
previous_token_hash = $3, -- hash vừa nộp
last_seen_at = now(),
expires_at = now() + interval '30 minutes'
WHERE id = $1
AND token_hash = $3
AND revoked_at IS NULL
AND expires_at > now();Nếu hai request chạy câu này cùng lúc với cùng một token, Postgres bắt chúng xếp hàng trên row lock. Ở mức isolation mặc định READ COMMITTED, câu UPDATE thứ hai sẽ chờ, rồi kiểm tra lại mệnh đề WHERE trên phiên bản dòng mà câu đầu đã commit. token_hash không còn khớp, nên nó cập nhật 0 dòng. Đúng một bên thắng, không cần lock tường minh, không cần vòng retry. Đây cũng chính là mẹo của cột version trong bài idempotency key và optimistic locking.
Còn đây là phiên bản trong repository, dùng Prisma, đã đổi tên đôi chút:
type RotationOutcome =
| { readonly kind: 'success' }
| { readonly kind: 'invalid' }
| { readonly kind: 'reused' };
export function rotateRefreshSession(input: RotateInput): Promise<RotationOutcome> {
return prisma.$transaction(async (tx): Promise<RotationOutcome> => {
const rotation = await tx.refreshSession.updateMany({
where: {
id: input.sessionId,
tokenHash: input.presentedHash,
revokedAt: null,
expiresAt: { gt: input.now },
},
data: {
tokenHash: input.nextHash,
previousTokenHash: input.presentedHash,
lastSeenAt: input.now,
expiresAt: input.idleExpiresAt,
},
});
if (rotation.count === 1) return { kind: 'success' };
const latest = await tx.refreshSession.findUnique({
where: { id: input.sessionId },
select: { previousTokenHash: true, revokedAt: true, expiresAt: true },
});
const replayedSpentToken =
latest?.previousTokenHash === input.presentedHash &&
latest.revokedAt === null &&
latest.expiresAt > input.now;
if (!replayedSpentToken) return { kind: 'invalid' };
await tx.refreshSession.updateMany({
where: { id: input.sessionId, revokedAt: null },
data: { revokedAt: input.now },
});
return { kind: 'reused' };
});
}Dùng updateMany là có chủ đích: update của Prisma đòi where theo khóa unique và ném lỗi khi không khớp dòng nào, còn updateMany nhận thêm điều kiện và trả về số dòng bị ảnh hưởng. Con số đó chính là kết quả của phép compare-and-swap.
Nhánh 0 dòng quan trọng không kém nhánh thành công. Thua race mà thấy token của mình nằm ở previousTokenHash: có người vừa xoay nó, tức là bị dùng lại. Không thấy ở đâu cả: chỉ đơn giản là invalid. Cả hai đều trả 401 nhưng khác mã lỗi, để client phân biệt được "phiên đã bị kết thúc vì lý do an toàn" với "mời đăng nhập lại".
Service còn kiểm tra một lần trước khi xoay: câu truy vấn tìm theo cả hai hash, và nếu khớp hash cũ thì đi thẳng tới revoke. Câu update có điều kiện là lớp chặn cuối cho trường hợp phát lại và xoay rơi đúng vào cùng một khoảnh khắc.
Lưu refresh token trên server thế nào cho đúng?
Lưu dạng hash, giống mật khẩu, nhưng bằng một loại hash khác:
import { createHash, randomBytes } from 'node:crypto';
const REFRESH_TOKEN_BYTES = 32;
export function generateRefreshToken(): string {
return randomBytes(REFRESH_TOKEN_BYTES).toString('base64url');
}
export function hashRefreshToken(token: string): string {
return createHash('sha256').update(token, 'utf8').digest('hex');
}32 byte ngẫu nhiên là 256 bit entropy, encode base64url ra 43 ký tự. Database chỉ giữ chuỗi hex SHA-256, nên một bản backup bảng session có bị lộ cũng không chứa thứ gì đem ra cửa soát được.
Sao không dùng bcrypt hay Argon2? Hash chậm sinh ra để bảo vệ bí mật entropy thấp: con người đặt mật khẩu dễ đoán, nên ta làm cho mỗi lần đoán thật đắt. Chẳng ai đoán nổi 256 bit ngẫu nhiên. Hash chậm lại có salt, nên không tra dòng theo nó được. SHA-256 thì tất định, nên token_hash có unique index và mỗi lần tra chỉ là một lần dò index; previous_token_hash có index thường. Phần còn lại của dòng cố tình để đơn giản: user id, expires_at, revoked_at, last_seen_at và vài thông tin thiết bị đã được che bớt.
Cookie hay localStorage: nên để refresh token ở đâu?
Trên trình duyệt, refresh token không bao giờ chạm tới JavaScript. Nó được set như sau (tên cookie đã rút gọn):
Set-Cookie: __Secure-refresh=<token>; HttpOnly; Secure; SameSite=Lax; Path=/api/v1/auth; Max-Age=1800Mỗi thuộc tính làm một việc:
HttpOnly: script không đọc được, nên một lỗi XSS không lấy trộm được nó.Securevà tiền tố__Secure-: chỉ đi qua HTTPS, và trình duyệt từ chối cookie nếu thiếuSecure.SameSite=Lax: cookie không được đính kèm vào request POST cross-site, nên trang khác không kích hoạt refresh được. Lưu ý "same-site" rộng hơn "same-origin": subdomain anh em vẫn tính là cùng site.Path=/api/v1/auth: chỉ gửi tới các route auth, không bao giờ tới phần còn lại của API. Đó là luật "chỉ đưa vé ở một cửa soát", do chính trình duyệt thực thi.Max-Age: bằng đúng idle window và được cấp lại sau mỗi lần xoay.
Endpoint refresh chỉ đọc token từ cookie, và body response chỉ có access_token với expires_in. Web client giữ access token trong bộ nhớ, không bao giờ trong localStorage. Mỗi lần tải trang, nó chỉ việc gọi refresh.
localStorage thì đơn giản hơn, nhưng cũng đọc được bởi mọi script trên origin của bạn, kể cả script lọt vào qua một dependency. Giữ bí mật sống lâu ngoài tầm với của script là lý do tôi chấp nhận độ phức tạp của cookie: CORS có credentials, SameSite và domain đều phải đúng, không thì cookie lặng lẽ không được gửi đi. Decision record trong repository ghi thẳng: cấu hình cookie đã có trong code, nhưng hành vi thực tế trên trình duyệt qua HTTPS thì chưa được kiểm chứng.
Vì sao mở hai tab lại khiến người dùng bị đăng xuất?
Mở ứng dụng ở hai tab cùng lúc, chẳng hạn khi trình duyệt khôi phục phiên làm việc trước. Tab nào khởi động cũng chưa có access token trong bộ nhớ nên đều gọi refresh, và vì cookie jar dùng chung, hai request mang cùng một refresh token.
Tab A thắng câu update có điều kiện. Câu của tab B khớp 0 dòng, thấy token của mình ở previousTokenHash, và revoke session. Người dùng chẳng làm gì sai mà bị đăng xuất ở cả hai tab.
Theo phép so sánh tàu điện: hai người trong cùng một nhà đi qua hai cửa soát trong cùng một giây với cùng một tấm vé. Cửa soát không thể biết họ là người nhà.
Web client trong repository đã chặn chuyện này trong phạm vi một tab: các lời gọi đồng thời dùng chung một promise refresh đang chờ thay vì mỗi cái tự gọi endpoint (kèm một bộ đếm generation để bỏ qua lần refresh nào xong sau khi người dùng đã logout). Rút gọn lại:
let pendingRefresh: Promise<string | null> | null = null;
export function refreshOnce(): Promise<string | null> {
pendingRefresh ??= requestNewAccessToken().finally(() => {
pendingRefresh = null;
});
return pendingRefresh;
}Nhưng nó không phối hợp giữa các tab. Cách tôi sẽ dùng là Web Locks API, vốn tuần tự hóa công việc giữa mọi tab của cùng một origin:
export function refreshAcrossTabs(): Promise<string | null> {
return navigator.locks.request('auth-refresh', () => refreshOnce());
}Giờ tab B chờ A. Tới lượt B thì cookie jar đã giữ token mới của A, nên lần refresh của B là một lần xoay hợp lệ chứ không phải phát lại.
Cách phổ biến khác là grace window phía server: chấp nhận token cũ thêm vài giây. Ở đây tôi sẽ tránh. Kẻ trộm phát lại trong khoảng đó cũng lọt, và vì chỉ lưu hash, server không thể trả lại token nó đã cấp. Nó buộc phải cấp thêm token thứ hai, tách session thành hai nhánh cùng sống, thứ mà một dòng chỉ có một hash hiện tại và một hash trước đó không biểu diễn nổi.
Response bị rơi giữa đường cũng gây ra đúng false positive này, dù chỉ có một tab. Server đã xoay, mạng làm mất response cùng với Set-Cookie, và lần refresh tiếp theo (retry hoặc tải lại trang) nộp lên token cũ. Theo định nghĩa thì đó là dùng lại. Đây chính là bài toán "request của mình đã chạy hay chưa?" trong bài idempotency, và ở đây tôi chọn cách hỏng an toàn: đăng xuất người dùng còn hơn liều để kẻ trộm ở lại.
Rotation không giải quyết được những gì?
XSS lợi dụng session đang sống. HttpOnly ngăn script đọc refresh token. Nó không ngăn một script chạy trên origin của bạn gọi endpoint refresh rồi dùng access token trả về. Không có gì bị phát lại, nên chuông không reo. Rotation chống bản sao bị trộm, không chống một trang đã bị chiếm quyền.
Kẻ trộm xoay hai lần trong lúc bạn vắng mặt. Cửa soát chỉ nhớ một tấm vé. Nếu người dùng gập laptop và kẻ trộm refresh hai lần, token của người dùng đã cũ hai thế hệ. Nó không khớp hash nào, nên chỉ bị coi là "invalid". Người dùng đăng nhập lại, nhận session mới, còn session của kẻ trộm vẫn sống. Cơ chế phát hiện chỉ hoạt động khi bản thật được dùng trong vòng một lần xoay kể từ bản bị trộm.
Session không bao giờ kết thúc. Mỗi lần xoay đẩy expires_at lùi thêm một idle window, và tôi không tìm thấy thời hạn tuyệt đối nào trong code session. Client nào refresh đều đặn thì giữ cùng một session mãi, kẻ trộm kiên nhẫn cũng vậy.
Chuông báo im lặng. Logout revoke session và ghi một event session-revoked qua transactional outbox trong cùng transaction. Nhánh reuse thì không ghi event nào, và dù sao trong repository cũng chưa có ai consume event đó. Tín hiệu bảo mật đáng chú ý nhất mà hệ thống tạo ra rốt cuộc chỉ thành một response 401 và một dòng log.
Thiết kế này phải trả giá những gì?
- Một lần đọc database cho mỗi request đã xác thực, cộng thêm một hop gRPC với các service phải hỏi auth service. Đó là giá của việc revoke có hiệu lực ngay, thay vì trễ tới 15 phút.
- Một lần ghi cho mỗi lần refresh của mỗi client đang hoạt động, đại khái mỗi vòng đời access token một lần.
- Đăng xuất oan vì race giữa các tab và vì response bị mất, nên lỗi reuse xứng đáng có mã lỗi và thông báo riêng.
- Một mớ cấu hình quanh cookie. CORS có credentials,
SameSite, domain và HTTPS phải khớp ở mọi môi trường, và khi hỏng thì triệu chứng là cookie lặng lẽ không được gửi.
Nếu làm lại, tôi sẽ làm khác gì?
Nhớ cả họ token, không chỉ một thế hệ. Mỗi token đã cấp là một dòng, kèm session id và mốc spent_at, giữ suốt vòng đời session. Khi đó mọi token cũ đều tính là dùng lại, và trường hợp kẻ trộm xoay hai lần sẽ bị phát hiện. Best current practice về bảo mật OAuth, RFC 9700, cũng lập luận y như vậy: khi một refresh token đã bị vô hiệu xuất hiện trở lại, server không biết bên nào gửi nó, nên revoke luôn token đang hoạt động.
Thêm thời hạn tuyệt đối bên trên idle window, để kẻ trộm dù im lặng đến đâu rồi cũng phải đăng nhập lại.
Cho chuông reo to. Phát cùng event session-revoked khi phát hiện dùng lại như khi logout, với lý do khác, và báo cho người dùng kiểu "phiên này đã bị kết thúc vì cùng một lần đăng nhập đang được dùng ở hai nơi".
Tuần tự hóa refresh giữa các tab ngay từ đầu. Vài dòng code phía client là xóa được loại false positive phổ biến nhất.
Test cookie trên trình duyệt thật (same-site và cross-site qua HTTPS: refresh, reuse, logout) trước khi gọi là xong. Cấu hình nằm trong code chứng minh ý định, không chứng minh trình duyệt làm theo.
Tóm tắt
- Refresh token chính là session. Chỉ đưa nó cho một endpoint, giữ nó ngoài tầm JavaScript, và chỉ lưu hash.
- Rotation không có trí nhớ chỉ chọn ra người thắng. Hãy nhớ hash trước đó và coi việc phát lại là dấu hiệu bị trộm: revoke session, vì không biết được ai là người ngay.
- Xoay bằng một câu
UPDATE ... WHERE token_hash = <token nộp lên>có điều kiện và kiểm tra số dòng. Đó là thứ làm cho các lần refresh đồng thời trở nên an toàn. - Dùng hash nhanh như SHA-256 cho token ngẫu nhiên 256 bit. Hash chậm có salt là dành cho mật khẩu do con người đặt.
- Chuẩn bị tinh thần cho false positive từ nhiều tab và từ response bị mất, và xử lý race giữa các tab ở phía client bằng lock liên tab.
- Biết giới hạn: chỉ nhớ một thế hệ, không có thời hạn tuyệt đối và chuông báo im lặng là ba lỗ tôi sẽ vá trước tiên.
Session là mảnh logic ứng dụng cuối cùng của series này. Quyết định cuối cùng là cả mười ba service thực sự chạy ở đâu: Docker Compose trên một máy, hay Kubernetes.