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):

  1. Token berada pada state ACTIVE.
  2. Klien meminta pasangan token baru menggunakan token tersebut.
  3. 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:

  1. Init: Token 1 berstatus ACTIVE.
  2. StartRefresh(c1, 1): Sesi klien c1 membaca Token 1 sebagai ACTIVE. State c1 berubah menjadi <<"VALIDATING", 1>>.
  3. StartRefresh(c2, 1): Sebelum c1 memperbarui database, klien c2 membaca Token 1 yang masih berstatus ACTIVE. State c2 berubah menjadi <<"VALIDATING", 1>>.
  4. TLC memicu invariant violation karena c1 dan c2 memvalidasi 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

AspekVerifikasi Formal (TLA+)Integration Testing
Cakupan State SpaceExhaustif; mengecek 100% kemungkinan interleaving instruksi.Probabilistik; bergantung pada timing OS scheduler dan hardware.
Kecepatan FeedbackSangat cepat saat desain arsitektur (sebelum koding dimulai).Lambat; membutuhkan pipeline database, network, dan runtime.
Cakupan BugMenangkap race condition logika, deadlock, dan liveness issue.Menangkap driver bugs, SQL syntax error, dan network timeout.
Kurva PembelajaranTinggi; 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.