sonda/internal/auth/service_test.go
tgiachi 7e59bd26af fix(auth): close session races found in review
- fix(storage): lock the user row when rotating a refresh token or changing a
  password, so on PostgreSQL a token minted during a password change can no
  longer survive the revoke-everything that runs at the same time
- fix(auth): a replay of a just-rotated refresh token (two tabs, a retrying
  client) now fails without revoking the winner's new token; only a replay
  after RefreshReuseGrace is treated as theft and revokes every session
- fix(auth): changing or resetting a password and revoking the user's refresh
  tokens now happen in one transaction
- docs(auth): note that the last-admin rule relies on a single instance
- test: password change racing with a refresh (25 rounds, both databases),
  grace window, winner's token still valid after concurrent rotation
2026-11-11 12:45:06 +01:00

486 lines
14 KiB
Go

package auth
import (
"context"
"errors"
"strings"
"testing"
"time"
)
// ---- fake stores ----
type fakeUserRow struct {
u User
hash string
}
type fakeRefreshRow struct {
userID int64
expires time.Time
revoked bool
revokedAt time.Time
}
// fakeStore implements UserStore and RefreshStore in memory, following the
// same rules as the real repositories.
type fakeStore struct {
users map[int64]*fakeUserRow
tokens map[string]*fakeRefreshRow // by hash
nextID int64
}
func newFakeStore() *fakeStore {
return &fakeStore{users: map[int64]*fakeUserRow{}, tokens: map[string]*fakeRefreshRow{}}
}
func (f *fakeStore) find(username string) *fakeUserRow {
for _, r := range f.users {
if strings.EqualFold(r.u.Username, username) {
return r
}
}
return nil
}
func (f *fakeStore) CountUsers(context.Context) (int, error) { return len(f.users), nil }
func (f *fakeStore) CountAdmins(context.Context) (int, error) {
n := 0
for _, r := range f.users {
if r.u.IsAdmin {
n++
}
}
return n, nil
}
func (f *fakeStore) CreateUser(_ context.Context, username, hash string, isAdmin bool) (User, error) {
if f.find(username) != nil {
return User{}, ErrUsernameTaken
}
f.nextID++
u := User{ID: f.nextID, Username: username, IsAdmin: isAdmin, CreatedAt: time.Now()}
f.users[u.ID] = &fakeUserRow{u: u, hash: hash}
return u, nil
}
func (f *fakeStore) UserByUsername(_ context.Context, username string) (User, string, error) {
r := f.find(username)
if r == nil {
return User{}, "", ErrUserNotFound
}
return r.u, r.hash, nil
}
func (f *fakeStore) UserByID(_ context.Context, id int64) (User, string, error) {
r, ok := f.users[id]
if !ok {
return User{}, "", ErrUserNotFound
}
return r.u, r.hash, nil
}
func (f *fakeStore) ListUsers(context.Context) ([]User, error) {
var out []User
for id := int64(1); id <= f.nextID; id++ {
if r, ok := f.users[id]; ok {
out = append(out, r.u)
}
}
return out, nil
}
func (f *fakeStore) SetAdmin(_ context.Context, id int64, isAdmin bool) error {
r, ok := f.users[id]
if !ok {
return ErrUserNotFound
}
r.u.IsAdmin = isAdmin
return nil
}
func (f *fakeStore) SetPasswordHash(_ context.Context, id int64, hash string, now time.Time) error {
r, ok := f.users[id]
if !ok {
return ErrUserNotFound
}
r.hash = hash
f.revokeUser(id, now) // same transaction in the real store
return nil
}
func (f *fakeStore) DeleteUser(_ context.Context, id int64) error {
if _, ok := f.users[id]; !ok {
return ErrUserNotFound
}
delete(f.users, id)
for h, t := range f.tokens { // cascade
if t.userID == id {
delete(f.tokens, h)
}
}
return nil
}
func (f *fakeStore) SaveRefreshToken(_ context.Context, t RefreshToken) error {
f.tokens[t.TokenHash] = &fakeRefreshRow{userID: t.UserID, expires: t.ExpiresAt}
return nil
}
func (f *fakeStore) revokeUser(userID int64, now time.Time) {
for _, t := range f.tokens {
if t.userID == userID && !t.revoked {
t.revoked, t.revokedAt = true, now
}
}
}
func (f *fakeStore) RotateRefreshToken(_ context.Context, oldHash string, next RefreshToken, now time.Time) (int64, error) {
t, ok := f.tokens[oldHash]
if !ok {
return 0, ErrInvalidRefreshToken
}
if t.revoked {
if now.Sub(t.revokedAt) > RefreshReuseGrace {
f.revokeUser(t.userID, now) // reuse after the grace window: assume theft
}
return 0, ErrInvalidRefreshToken
}
if !now.Before(t.expires) {
return 0, ErrInvalidRefreshToken
}
t.revoked, t.revokedAt = true, now
f.tokens[next.TokenHash] = &fakeRefreshRow{userID: t.userID, expires: next.ExpiresAt}
return t.userID, nil
}
func (f *fakeStore) RevokeRefreshToken(_ context.Context, hash string, now time.Time) error {
if t, ok := f.tokens[hash]; ok && !t.revoked {
t.revoked, t.revokedAt = true, now
}
return nil
}
func newTestService() (*Service, *fakeStore) {
st := newFakeStore()
return NewService(st, st, NewTokenIssuer(testSecret, 15*time.Minute), 24*time.Hour), st
}
// bootstrap registers the first (admin) user and returns the service.
func bootstrap(t *testing.T) (*Service, *fakeStore, User) {
t.Helper()
s, st := newTestService()
u, err := s.Register(context.Background(), "alice", "longenough")
if err != nil {
t.Fatal(err)
}
return s, st, u
}
// ---- register / login ----
func TestRegisterFirstUserIsAdminThenClosed(t *testing.T) {
s, _, u := bootstrap(t)
if !u.IsAdmin {
t.Error("the first user must be an admin")
}
if _, err := s.Register(context.Background(), "bob", "longenough"); !errors.Is(err, ErrRegistrationClosed) {
t.Fatalf("err = %v, want ErrRegistrationClosed", err)
}
}
func TestRegisterValidation(t *testing.T) {
tests := []struct {
name, user, pass string
}{
{"short username", "ab", "longenough"},
{"long username", strings.Repeat("a", 65), "longenough"},
{"bad chars", "bad name!", "longenough"},
{"short password", "alice", "short"},
{"huge password", "alice", strings.Repeat("x", 300)},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s, _ := newTestService()
if _, err := s.Register(context.Background(), tt.user, tt.pass); !errors.Is(err, ErrInvalidInput) {
t.Fatalf("err = %v, want ErrInvalidInput", err)
}
})
}
}
func TestLoginIssuesBothTokens(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
sess, err := s.Login(ctx, "ALICE", "longenough") // usernames are case-insensitive
if err != nil {
t.Fatal(err)
}
if sess.AccessToken == "" || sess.RefreshToken == "" || sess.User.Username != "alice" || !sess.User.IsAdmin {
t.Fatalf("session = %+v", sess)
}
if !sess.RefreshExpiresAt.After(sess.AccessExpiresAt) {
t.Error("refresh token must outlive the access token")
}
if _, err := NewTokenIssuer(testSecret, time.Hour).Parse(sess.AccessToken); err != nil {
t.Errorf("access token does not verify: %v", err)
}
if _, err := s.Login(ctx, "alice", "wrongpass1"); !errors.Is(err, ErrInvalidCredentials) {
t.Errorf("wrong password: err = %v", err)
}
if _, err := s.Login(ctx, "nobody", "longenough"); !errors.Is(err, ErrInvalidCredentials) {
t.Errorf("unknown user: err = %v", err)
}
}
func TestRefreshTokenIsStoredHashed(t *testing.T) {
s, st, _ := bootstrap(t)
sess, _ := s.Login(context.Background(), "alice", "longenough")
if _, ok := st.tokens[sess.RefreshToken]; ok {
t.Fatal("the raw refresh token is stored; only its hash may be")
}
if _, ok := st.tokens[hashRefreshToken(sess.RefreshToken)]; !ok {
t.Fatal("hash of the refresh token not stored")
}
}
// ---- refresh ----
func TestRefreshRotates(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
first, _ := s.Login(ctx, "alice", "longenough")
second, err := s.Refresh(ctx, first.RefreshToken)
if err != nil {
t.Fatal(err)
}
if second.RefreshToken == first.RefreshToken || second.AccessToken == "" || second.User.Username != "alice" {
t.Fatalf("second = %+v", second)
}
// The new token works.
if _, err := s.Refresh(ctx, second.RefreshToken); err != nil {
t.Fatalf("refreshing with the new token: %v", err)
}
}
func TestReusedRefreshTokenRevokesEverySession(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
first, _ := s.Login(ctx, "alice", "longenough")
second, _ := s.Refresh(ctx, first.RefreshToken)
// Well after the grace window, presenting the rotated token looks like theft.
s.now = func() time.Time { return time.Now().Add(RefreshReuseGrace + time.Minute) }
if _, err := s.Refresh(ctx, first.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Fatalf("reuse: err = %v, want ErrInvalidRefreshToken", err)
}
// ...so the legitimate newer token is dead too.
if _, err := s.Refresh(ctx, second.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Fatalf("after reuse the newer token must be revoked: err = %v", err)
}
}
// Two tabs, or a client retrying in parallel, present the same token almost
// at once. The loser fails but must not log the winner out.
func TestReplayInsideTheGraceWindowKeepsTheNewToken(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
first, _ := s.Login(ctx, "alice", "longenough")
second, err := s.Refresh(ctx, first.RefreshToken)
if err != nil {
t.Fatal(err)
}
if _, err := s.Refresh(ctx, first.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Fatalf("the replay itself must still fail: err = %v", err)
}
if _, err := s.Refresh(ctx, second.RefreshToken); err != nil {
t.Fatalf("a replay inside the grace window must not revoke the new token: %v", err)
}
}
func TestRefreshRejectsExpiredUnknownAndEmpty(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
sess, _ := s.Login(ctx, "alice", "longenough")
for _, tok := range []string{"", "not-a-token", strings.Repeat("a", 43)} {
if _, err := s.Refresh(ctx, tok); !errors.Is(err, ErrInvalidRefreshToken) {
t.Errorf("token %q: err = %v", tok, err)
}
}
s.now = func() time.Time { return time.Now().Add(48 * time.Hour) }
if _, err := s.Refresh(ctx, sess.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Errorf("expired token: err = %v", err)
}
}
func TestRefreshFailsForDeletedUser(t *testing.T) {
s, _, admin := bootstrap(t)
ctx := context.Background()
bob, err := s.CreateUser(ctx, "bob", "longenough", false)
if err != nil {
t.Fatal(err)
}
bobSess, _ := s.Login(ctx, "bob", "longenough")
if err := s.DeleteUser(ctx, bob.ID); err != nil {
t.Fatal(err)
}
if _, err := s.Refresh(ctx, bobSess.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Fatalf("err = %v", err)
}
_ = admin
}
// ---- logout / password ----
func TestLogoutRevokesTheToken(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
sess, _ := s.Login(ctx, "alice", "longenough")
if err := s.Logout(ctx, sess.RefreshToken); err != nil {
t.Fatal(err)
}
if _, err := s.Refresh(ctx, sess.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Fatalf("after logout: err = %v", err)
}
// Logging out twice, or with garbage, is not an error.
if err := s.Logout(ctx, sess.RefreshToken); err != nil {
t.Errorf("second logout: %v", err)
}
if err := s.Logout(ctx, "garbage"); err != nil {
t.Errorf("garbage logout: %v", err)
}
}
func TestChangePassword(t *testing.T) {
s, _, u := bootstrap(t)
ctx := context.Background()
sess, _ := s.Login(ctx, "alice", "longenough")
if err := s.ChangePassword(ctx, u.ID, "wrong-current", "brandnewpass"); !errors.Is(err, ErrInvalidCredentials) {
t.Fatalf("wrong current: err = %v", err)
}
if err := s.ChangePassword(ctx, u.ID, "longenough", "short"); !errors.Is(err, ErrInvalidInput) {
t.Fatalf("weak new password: err = %v", err)
}
if err := s.ChangePassword(ctx, u.ID, "longenough", "brandnewpass"); err != nil {
t.Fatal(err)
}
if _, err := s.Login(ctx, "alice", "longenough"); !errors.Is(err, ErrInvalidCredentials) {
t.Error("old password still works")
}
if _, err := s.Login(ctx, "alice", "brandnewpass"); err != nil {
t.Errorf("new password: %v", err)
}
if _, err := s.Refresh(ctx, sess.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Error("a password change must revoke existing sessions")
}
}
// ---- admin ----
func TestAdminCreateAndListUsers(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
bob, err := s.CreateUser(ctx, "bob", "longenough", false)
if err != nil || bob.IsAdmin {
t.Fatalf("bob = %+v err=%v", bob, err)
}
if _, err := s.CreateUser(ctx, "BOB", "longenough", false); !errors.Is(err, ErrUsernameTaken) {
t.Errorf("duplicate: err = %v", err)
}
if _, err := s.CreateUser(ctx, "x", "longenough", false); !errors.Is(err, ErrInvalidInput) {
t.Errorf("bad username: err = %v", err)
}
users, err := s.ListUsers(ctx)
if err != nil || len(users) != 2 || users[0].Username != "alice" || users[1].Username != "bob" {
t.Fatalf("users = %+v err=%v", users, err)
}
}
func TestSetAdminAndLastAdminGuard(t *testing.T) {
s, _, alice := bootstrap(t)
ctx := context.Background()
bob, _ := s.CreateUser(ctx, "bob", "longenough", false)
// The only admin cannot be demoted.
if _, err := s.SetAdmin(ctx, alice.ID, false); !errors.Is(err, ErrLastAdmin) {
t.Fatalf("demoting the last admin: err = %v", err)
}
got, err := s.SetAdmin(ctx, bob.ID, true)
if err != nil || !got.IsAdmin {
t.Fatalf("promote: %+v err=%v", got, err)
}
// With two admins, one can step down.
if got, err = s.SetAdmin(ctx, alice.ID, false); err != nil || got.IsAdmin {
t.Fatalf("demote with two admins: %+v err=%v", got, err)
}
// Now bob is the last one.
if _, err := s.SetAdmin(ctx, bob.ID, false); !errors.Is(err, ErrLastAdmin) {
t.Fatalf("demoting the new last admin: err = %v", err)
}
if _, err := s.SetAdmin(ctx, 999, true); !errors.Is(err, ErrUserNotFound) {
t.Errorf("unknown user: err = %v", err)
}
}
func TestDeleteUserGuards(t *testing.T) {
s, _, alice := bootstrap(t)
ctx := context.Background()
bob, _ := s.CreateUser(ctx, "bob", "longenough", false)
if err := s.DeleteUser(ctx, alice.ID); !errors.Is(err, ErrLastAdmin) {
t.Fatalf("deleting the last admin: err = %v", err)
}
if err := s.DeleteUser(ctx, bob.ID); err != nil {
t.Fatal(err)
}
if err := s.DeleteUser(ctx, bob.ID); !errors.Is(err, ErrUserNotFound) {
t.Errorf("deleting twice: err = %v", err)
}
}
func TestResetPasswordRevokesSessions(t *testing.T) {
s, _, _ := bootstrap(t)
ctx := context.Background()
bob, _ := s.CreateUser(ctx, "bob", "longenough", false)
sess, _ := s.Login(ctx, "bob", "longenough")
if err := s.ResetPassword(ctx, bob.ID, "short"); !errors.Is(err, ErrInvalidInput) {
t.Fatalf("weak password: err = %v", err)
}
if err := s.ResetPassword(ctx, bob.ID, "resetpassword"); err != nil {
t.Fatal(err)
}
if _, err := s.Login(ctx, "bob", "resetpassword"); err != nil {
t.Errorf("login with the reset password: %v", err)
}
if _, err := s.Refresh(ctx, sess.RefreshToken); !errors.Is(err, ErrInvalidRefreshToken) {
t.Error("a reset must revoke the user's sessions")
}
if err := s.ResetPassword(ctx, 999, "resetpassword"); !errors.Is(err, ErrUserNotFound) {
t.Errorf("unknown user: err = %v", err)
}
}
func TestUserLookup(t *testing.T) {
s, _, alice := bootstrap(t)
u, err := s.User(context.Background(), alice.ID)
if err != nil || u.Username != "alice" || !u.IsAdmin {
t.Fatalf("u = %+v err=%v", u, err)
}
if _, err := s.User(context.Background(), 999); !errors.Is(err, ErrUserNotFound) {
t.Errorf("err = %v", err)
}
}