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.
145 lines
4.7 KiB
Go
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
|
|
}
|