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 ", "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) } }