sonda/internal/storage/refresh.go
tgiachi a880b87a9e chore: move the module path to git.kmalloc.org/squid/sonda
Migrating hosting from Codeberg to git.kmalloc.org. Renames the
module path in go.mod, every internal import, and the OCI image
source label in the Dockerfile. Build and full test suite verified
green after the rename.
2026-11-15 17:30:29 +01:00

145 lines
4.7 KiB
Go

package storage
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"github.com/uptrace/bun"
"git.kmalloc.org/squid/sonda/internal/auth"
)
type refreshRow struct {
bun.BaseModel `bun:"table:refresh_tokens"`
ID int64 `bun:"id,pk,autoincrement"`
UserID int64 `bun:"user_id,notnull"`
TokenHash string `bun:"token_hash,notnull"`
CreatedAt int64 `bun:"created_at,notnull"`
ExpiresAt int64 `bun:"expires_at,notnull"`
RevokedAt sql.NullInt64 `bun:"revoked_at"`
}
// RefreshRepo stores refresh token hashes. It implements auth.RefreshStore.
type RefreshRepo struct{ db *bun.DB }
// NewRefreshRepo builds a RefreshRepo.
func NewRefreshRepo(db *bun.DB) *RefreshRepo { return &RefreshRepo{db: db} }
// SaveRefreshToken stores a new active token.
func (r *RefreshRepo) SaveRefreshToken(ctx context.Context, t auth.RefreshToken) error {
row := &refreshRow{
UserID: t.UserID, TokenHash: t.TokenHash,
CreatedAt: time.Now().Unix(), ExpiresAt: t.ExpiresAt.Unix(),
}
if _, err := r.db.NewInsert().Model(row).Exec(ctx); err != nil {
return fmt.Errorf("insert refresh token: %w", err)
}
return nil
}
// RotateRefreshToken revokes an active token and stores its successor in one
// transaction. The revoke is a single conditional UPDATE, so of any number of
// concurrent calls with the same token exactly one succeeds.
//
// The user row is locked first. That serialises the rotation with a password
// change (which also touches the user row) so a token minted here can never
// slip past a "revoke everything" running at the same time.
func (r *RefreshRepo) RotateRefreshToken(ctx context.Context, oldHash string, next auth.RefreshToken, now time.Time) (int64, error) {
var userID int64
err := r.db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
var old refreshRow
err := tx.NewSelect().Model(&old).Where("token_hash = ?", oldHash).Limit(1).Scan(ctx)
if errors.Is(err, sql.ErrNoRows) {
return nil // unknown token: reported below
}
if err != nil {
return fmt.Errorf("select refresh token: %w", err)
}
if err := lockUser(ctx, tx, old.UserID); err != nil {
return err
}
res, err := tx.NewUpdate().Model((*refreshRow)(nil)).
Set("revoked_at = ?", now.Unix()).
Where("token_hash = ?", oldHash).
Where("revoked_at IS NULL").
Where("expires_at > ?", now.Unix()).
Exec(ctx)
if err != nil {
return fmt.Errorf("revoke refresh token: %w", err)
}
n, err := res.RowsAffected()
if err != nil {
return err
}
if n == 0 {
// Revoked or expired. Read the row again: it may have changed while
// we waited for the user lock.
var cur refreshRow
if err := tx.NewSelect().Model(&cur).Where("token_hash = ?", oldHash).Limit(1).Scan(ctx); err != nil {
return fmt.Errorf("reload refresh token: %w", err)
}
// Revoked long ago: somebody presented a spent token, assume theft
// and end every session. Revoked moments ago it is just two
// requests racing (two tabs, a retry), so only this call fails.
if cur.RevokedAt.Valid && now.Unix()-cur.RevokedAt.Int64 > int64(auth.RefreshReuseGrace/time.Second) {
return revokeUserTokens(ctx, tx, cur.UserID, now)
}
return nil
}
userID = old.UserID
row := &refreshRow{
UserID: userID, TokenHash: next.TokenHash,
CreatedAt: now.Unix(), ExpiresAt: next.ExpiresAt.Unix(),
}
if _, err := tx.NewInsert().Model(row).Exec(ctx); err != nil {
return fmt.Errorf("insert next refresh token: %w", err)
}
return nil
})
if err != nil {
return 0, err
}
if userID == 0 {
return 0, auth.ErrInvalidRefreshToken
}
return userID, nil
}
// lockUser takes the row lock of a user for the rest of the transaction.
func lockUser(ctx context.Context, tx bun.Tx, userID int64) error {
if _, err := tx.NewUpdate().Model((*userRow)(nil)).
Set("id = id").Where("id = ?", userID).Exec(ctx); err != nil {
return fmt.Errorf("lock user: %w", err)
}
return nil
}
// revokeUserTokens revokes every active refresh token of a user.
func revokeUserTokens(ctx context.Context, tx bun.Tx, userID int64, now time.Time) error {
_, err := tx.NewUpdate().Model((*refreshRow)(nil)).
Set("revoked_at = ?", now.Unix()).
Where("user_id = ?", userID).Where("revoked_at IS NULL").Exec(ctx)
if err != nil {
return fmt.Errorf("revoke user refresh tokens: %w", err)
}
return nil
}
// RevokeRefreshToken revokes one token. Unknown or already revoked tokens are ignored.
func (r *RefreshRepo) RevokeRefreshToken(ctx context.Context, hash string, now time.Time) error {
_, err := r.db.NewUpdate().Model((*refreshRow)(nil)).
Set("revoked_at = ?", now.Unix()).
Where("token_hash = ?", hash).Where("revoked_at IS NULL").Exec(ctx)
if err != nil {
return fmt.Errorf("revoke refresh token: %w", err)
}
return nil
}