Registration, login and the admin's create-user call take `email` instead of `username`, and the user object returns `email`. The address is checked for its shape (a plain address, no display name, at most 254 bytes), trimmed, lowercased and unique. Sonda sends no mail and does not verify it. - Migration 0018 renames the users column (and the PostgreSQL index); values are kept, so an account made before keeps its plain name and still logs in with it (login does not check the shape). - Error code username_taken becomes email_taken; the JWT claim is now `email`, so access tokens issued before the upgrade are refused once and clients refresh. - OpenAPI spec, README, the web login form (type email), strings (en, it) and the generated API types follow. Closes #65
521 lines
16 KiB
Go
521 lines
16 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(email string) *fakeUserRow {
|
|
for _, r := range f.users {
|
|
if strings.EqualFold(r.u.Email, email) {
|
|
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, email, hash string, isAdmin bool) (User, error) {
|
|
if f.find(email) != nil {
|
|
return User{}, ErrEmailTaken
|
|
}
|
|
f.nextID++
|
|
u := User{ID: f.nextID, Email: email, IsAdmin: isAdmin, CreatedAt: time.Now()}
|
|
f.users[u.ID] = &fakeUserRow{u: u, hash: hash}
|
|
return u, nil
|
|
}
|
|
|
|
func (f *fakeStore) UserByEmail(_ context.Context, email string) (User, string, error) {
|
|
r := f.find(email)
|
|
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@example.org", "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@example.org", "longenough"); !errors.Is(err, ErrRegistrationClosed) {
|
|
t.Fatalf("err = %v, want ErrRegistrationClosed", err)
|
|
}
|
|
}
|
|
|
|
func TestRegisterValidation(t *testing.T) {
|
|
tests := []struct {
|
|
name, user, pass string
|
|
}{
|
|
{"no address", "", "longenough"},
|
|
{"a name, not an address", "alice", "longenough"},
|
|
{"no domain", "alice@", "longenough"},
|
|
{"no name", "@example.org", "longenough"},
|
|
{"two at signs", "a@b@example.org", "longenough"},
|
|
{"a space", "al ice@example.org", "longenough"},
|
|
{"a display name", "Alice <alice@example.org>", "longenough"},
|
|
{"too long", strings.Repeat("a", 250) + "@example.org", "longenough"},
|
|
{"short password", "alice@example.org", "short"},
|
|
{"huge password", "alice@example.org", 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@Example.org", "longenough") // addresses are case-insensitive
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if sess.AccessToken == "" || sess.RefreshToken == "" || sess.User.Email != "alice@example.org" || !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@example.org", "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@example.org", "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@example.org", "longenough")
|
|
|
|
second, err := s.Refresh(ctx, first.RefreshToken)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if second.RefreshToken == first.RefreshToken || second.AccessToken == "" || second.User.Email != "alice@example.org" {
|
|
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@example.org", "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@example.org", "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@example.org", "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@example.org", "longenough", false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
bobSess, _ := s.Login(ctx, "bob@example.org", "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@example.org", "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@example.org", "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@example.org", "longenough"); !errors.Is(err, ErrInvalidCredentials) {
|
|
t.Error("old password still works")
|
|
}
|
|
if _, err := s.Login(ctx, "alice@example.org", "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@example.org", "longenough", false)
|
|
if err != nil || bob.IsAdmin {
|
|
t.Fatalf("bob = %+v err=%v", bob, err)
|
|
}
|
|
if _, err := s.CreateUser(ctx, "BOB@example.org", "longenough", false); !errors.Is(err, ErrEmailTaken) {
|
|
t.Errorf("duplicate: err = %v", err)
|
|
}
|
|
if _, err := s.CreateUser(ctx, "x", "longenough", false); !errors.Is(err, ErrInvalidInput) {
|
|
t.Errorf("bad email: err = %v", err)
|
|
}
|
|
users, err := s.ListUsers(ctx)
|
|
if err != nil || len(users) != 2 || users[0].Email != "alice@example.org" || users[1].Email != "bob@example.org" {
|
|
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@example.org", "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@example.org", "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@example.org", "longenough", false)
|
|
sess, _ := s.Login(ctx, "bob@example.org", "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@example.org", "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.Email != "alice@example.org" || !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)
|
|
}
|
|
}
|
|
|
|
func TestAnAddressIsTrimmedAndLowercased(t *testing.T) {
|
|
s, _ := newTestService()
|
|
ctx := context.Background()
|
|
u, err := s.Register(ctx, " Alice@Example.ORG ", "longenough")
|
|
if err != nil || u.Email != "alice@example.org" {
|
|
t.Fatalf("user = %+v err = %v", u, err)
|
|
}
|
|
if _, err := s.Login(ctx, " ALICE@example.org", "longenough"); err != nil {
|
|
t.Errorf("login with another spelling: %v", err)
|
|
}
|
|
if _, err := s.CreateUser(ctx, "alice@EXAMPLE.org", "longenough", false); !errors.Is(err, ErrEmailTaken) {
|
|
t.Errorf("same address, other case: err = %v", err)
|
|
}
|
|
}
|
|
|
|
// Accounts made before addresses were asked for have a plain name: it stays their login.
|
|
func TestAnOldAccountNameStillLogsIn(t *testing.T) {
|
|
s, st := newTestService()
|
|
hash, err := HashPassword("longenough")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := st.CreateUser(context.Background(), "olduser", hash, true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := s.Login(context.Background(), "OldUser", "longenough"); err != nil {
|
|
t.Errorf("an old name no longer logs in: %v", err)
|
|
}
|
|
}
|