Celah keamanan pada sistem session token sering kali bukan disebabkan oleh algoritma kriptografi yang lemah, melainkan kesalahan logika pada state transition yang dieksekusi secara konkuren. Kasus concurrent refresh token reuse terjadi ketika dua permintaan refresh identik tiba pada milidetik yang sama, melewati pemeriksaan validitas database sebelum salah satu menandai token tersebut sebagai invalid. Integration test konvensional sering gagal mendeteksi celah ini karena keterbatasan non-determinisme thread scheduler pada runtime pengujian.
Verifikasi formal dengan TLA+ (Temporal Logic of Actions) menyelesaikan masalah ini dengan mengeksplorasi seluruh ruang kemungkinan state (state space) secara exhaustif sebelum kode ditulis. Pendekatan ini membuktikan secara matematis apakah invariant keamanan sistem dapat dilanggar dalam skenario interweaving instruksi apa pun.
State Machine Autentikasi dan Celah Race Condition
Siklus hidup refresh token umumnya mengikuti mekanisme rotasi satu kali pakai (one-time use rotation):
- Token berada pada state
ACTIVE. - Klien meminta pasangan token baru menggunakan token tersebut.
- Sistem memvalidasi token, menandai token lama menjadi
REVOKED, dan menerbitkan token baru.
Jika verifikasi state dan transisi update tidak bersifat atomik, eksekusi paralel dari dua request (R1 dan R2) menghasilkan interweaving berikut:
R1: SELECT status FROM sessions WHERE id = 1; -- Mengembalikan ACTIVE
R2: SELECT status FROM sessions WHERE id = 1; -- Mengembalikan ACTIVE
R1: UPDATE sessions SET status = 'REVOKED' WHERE id = 1; -- Mengeluarkan token T2
R2: UPDATE sessions SET status = 'REVOKED' WHERE id = 1; -- Mengeluarkan token T3 (Bypass)Dua sesi aktif kini bercabang dari satu refresh token yang sama. Untuk membuktikan dan mencegah skenario ini, kita definisikan model formal state machine menggunakan TLA+.
Spesifikasi TLA+ Minimal: Token Refresh
Berikut spesifikasi TLA+ untuk memodelkan proses refresh konkuren dengan model checker TLC. Model ini mendefinisikan status token, permintaan konkuren oleh klien, dan verifikasi invariant.
--------------------------- MODULE SessionAuth ---------------------------
EXTENDS Naturals, Sequences
CONSTANTS Clients, MaxTokens
VARIABLES tokenStatus, clientState, issuedTokens
Statuses == {"ACTIVE", "REVOKED", "NOT_FOUND"}
Init ==
/\ tokenStatus = [t \in 1..MaxTokens |-> IF t = 1 THEN "ACTIVE" ELSE "NOT_FOUND"]
/\ clientState = [c \in Clients |-> "IDLE"]
/\ issuedTokens = 1
(* Action: Klien membaca token dan mengirim request *)
StartRefresh(c, t) ==
/\ clientState[c] = "IDLE"
/\ tokenStatus[t] = "ACTIVE"
/\ clientState' = [clientState EXCEPT ![c] = <<"VALIDATING", t>>]
/\ UNCHANGED <<tokenStatus, issuedTokens>>
(* Action non-atomik: Klien menyelesaikan refresh token *)
FinishRefreshUnsafe(c) ==
\E t \in 1..MaxTokens:
/\ clientState[c] = <<"VALIDATING", t>>
/\ issuedTokens < MaxTokens
/\ tokenStatus' = [tokenStatus EXCEPT ![t] = "REVOKED", ![issuedTokens + 1] = "ACTIVE"]
/\ issuedTokens' = issuedTokens + 1
/\ clientState' = [clientState EXCEPT ![c] = "IDLE"]
Next ==
\E c \in Clients:
\/ (\E t \in 1..MaxTokens: StartRefresh(c, t))
\/ FinishRefreshUnsafe(c)
(* Invariant Keamanan: Tidak boleh ada token anak ganda dari parent yang sama *)
MutualExclusion ==
\A c1, c2 \in Clients:
(c1 /= c2 /\ clientState[c1] /= "IDLE" /\ clientState[c2] /= "IDLE") =>
clientState[c1][2] /= clientState[c2][2]
=============================================================================Mendeteksi Counterexample Menggunakan TLC
Ketika model di atas diuji dengan TLC (mengatur konfigurasi Clients = {c1, c2} dan MaxTokens = 3), TLC akan langsung menampilkan violation trace pada invariant MutualExclusion:
Init: Token 1 berstatusACTIVE.StartRefresh(c1, 1): Sesi klienc1membaca Token 1 sebagaiACTIVE. Statec1berubah menjadi<<"VALIDATING", 1>>.StartRefresh(c2, 1): Sebelumc1memperbarui database, klienc2membaca Token 1 yang masih berstatusACTIVE. Statec2berubah menjadi<<"VALIDATING", 1>>.- TLC memicu invariant violation karena
c1danc2memvalidasi token yang sama secara paralel.
Implementasi Backend: Go dan PostgreSQL
Solusi yang terverifikasi secara formal mengharuskan transisi pembacaan status dan penandaan revocasi bersifat atomik. Di PostgreSQL, ini dilakukan melalui explicit locking SELECT ... FOR UPDATE atau update kondisional dalam satu transaksi atomik.
package auth
import (
"context"
"database/sql"
"errors"
"fmt"
)
var ErrInvalidToken = errors.New("token invalid atau sedang diproses")
type SessionService struct {
DB *sql.DB
}
func (s *SessionService) RotateRefreshToken(ctx context.Context, currentTokenID string) (string, error) {
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
if err != nil {
return "", fmt.Errorf("begin tx: %w", err)
}
defer tx.Rollback()
// Atomic conditional update: Hanya 1 transaksi konkuren yang berhasil mengubah baris
query := `
UPDATE refresh_tokens
SET status = 'REVOKED', updated_at = NOW()
WHERE id = $1 AND status = 'ACTIVE'
RETURNING user_id;
`
var userID string
err = tx.QueryRowContext(ctx, query, currentTokenID).Scan(&userID)
if errors.Is(err, sql.ErrNoRows) {
// Deteksi anomali: Token sudah pernah digunakan atau tidak valid
return "", ErrInvalidToken
} else if err != nil {
return "", fmt.Errorf("update status token: %w", err)
}
// Terbitkan token pengganti baru dalam transaksi yang sama
var newTokenID string
insertQuery := `
INSERT INTO refresh_tokens (user_id, status)
VALUES ($1, 'ACTIVE')
RETURNING id;
`
err = tx.QueryRowContext(ctx, insertQuery, userID).Scan(&newTokenID)
if err != nil {
return "", fmt.Errorf("insert new token: %w", err)
}
if err := tx.Commit(); err != nil {
return "", fmt.Errorf("commit tx: %w", err)
}
return newTokenID, nil
}Penggunaan pernyataan UPDATE ... WHERE status = 'ACTIVE' mengeksekusi row-level lock pada level engine storage. Transaksi kedua yang mencoba membaca baris yang sama akan diblokir hingga transaksi pertama commit, kemudian gagal mendapatkan baris (mengembalikan sql.ErrNoRows) karena predikat status = 'ACTIVE' sudah tidak terpenuhi.
Trade-off: Verifikasi Formal vs Integration Testing
| Aspek | Verifikasi Formal (TLA+) | Integration Testing |
|---|---|---|
| Cakupan State Space | Exhaustif; mengecek 100% kemungkinan interleaving instruksi. | Probabilistik; bergantung pada timing OS scheduler dan hardware. |
| Kecepatan Feedback | Sangat cepat saat desain arsitektur (sebelum koding dimulai). | Lambat; membutuhkan pipeline database, network, dan runtime. |
| Cakupan Bug | Menangkap race condition logika, deadlock, dan liveness issue. | Menangkap driver bugs, SQL syntax error, dan network timeout. |
| Kurva Pembelajaran | Tinggi; membutuhkan pemahaman logika predikat dan TLA+. | Rendah; menggunakan sintaks bahasa pemrograman utama. |
Verifikasi formal bukan pengganti integration testing. Gunakan TLA+ untuk mendesain dan memvalidasi protokol state stateful yang rawan race condition, lalu tulis integration test untuk memvalidasi interaksi database driver, skema SQL, dan konfigurasi connection pool pada level implementasi.
Komentar
0 komentar
Masuk ke akun kamu untuk ikut berkomentar.
Belum ada komentar
Jadilah yang pertama ikut berdiskusi!