CI / test (push) Failing after 1m11s
The account system shipped without either, which made the first forgotten password an unanswerable support request. Changing it requires the current one. A session is what an attacker gets from a borrowed laptop or a stolen cookie; the password is what they do not have, and without the check the first thing they would do is take the account. Every session is closed, including the browser doing the changing — leaving the others open would mean a password change does nothing about the reason someone is changing it. A new session is then opened for the browser in front of us, so the person who just proved their password is not thrown back to the sign-in page. That response also carries a new CSRF cookie, so the forms it renders take the new token rather than the one the request arrived with; there is a test that posts a form from that exact page. Guessing the current password is bounded the same way sign-in is, because someone holding a stolen session should not get unlimited attempts at the password that would let them keep it. There is no self-service reset: this gateway sends no email, and a reset link with nowhere to send it is not a reset. `llmgw users reset-password` is the operator's answer, and it closes their sessions too — if someone lost their password, the reason might be that somebody else has it. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
398 lines
12 KiB
Go
398 lines
12 KiB
Go
package e2e
|
|
|
|
import (
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"net/http/cookiejar"
|
|
"net/url"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.mynodes.xyz/ilker/llmgw/internal/config"
|
|
"gitea.mynodes.xyz/ilker/llmgw/internal/store"
|
|
)
|
|
|
|
// browser is a client that keeps cookies and does not follow redirects, so a
|
|
// test can see them.
|
|
type browser struct {
|
|
t *testing.T
|
|
base string
|
|
c *http.Client
|
|
}
|
|
|
|
func newBrowser(t *testing.T, base string) *browser {
|
|
t.Helper()
|
|
jar, err := cookiejar.New(nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return &browser{t: t, base: base, c: &http.Client{
|
|
Jar: jar,
|
|
CheckRedirect: func(*http.Request, []*http.Request) error {
|
|
return http.ErrUseLastResponse
|
|
},
|
|
}}
|
|
}
|
|
|
|
func (b *browser) get(path string) (int, string) {
|
|
b.t.Helper()
|
|
req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, b.base+path, nil)
|
|
resp, err := b.c.Do(req)
|
|
if err != nil {
|
|
b.t.Fatal(err)
|
|
}
|
|
defer resp.Body.Close()
|
|
body, _ := io.ReadAll(resp.Body)
|
|
return resp.StatusCode, string(body)
|
|
}
|
|
|
|
func (b *browser) post(path string, form url.Values) (int, string, string) {
|
|
b.t.Helper()
|
|
req, _ := http.NewRequestWithContext(context.Background(), http.MethodPost,
|
|
b.base+path, strings.NewReader(form.Encode()))
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
resp, err := b.c.Do(req)
|
|
if err != nil {
|
|
b.t.Fatal(err)
|
|
}
|
|
defer resp.Body.Close()
|
|
body, _ := io.ReadAll(resp.Body)
|
|
return resp.StatusCode, string(body), resp.Header.Get("Location")
|
|
}
|
|
|
|
// csrf pulls the token the server put in the page's forms.
|
|
func csrf(t *testing.T, body string) string {
|
|
t.Helper()
|
|
const marker = `name="csrf" value="`
|
|
i := strings.Index(body, marker)
|
|
if i < 0 {
|
|
t.Fatal("no csrf token in the page")
|
|
}
|
|
rest := body[i+len(marker):]
|
|
return rest[:strings.IndexByte(rest, '"')]
|
|
}
|
|
|
|
func signupHarness(t *testing.T) (*harness, string) {
|
|
t.Helper()
|
|
path, _ := provision(t)
|
|
h := start(t, 2, func(c *config.Server) {
|
|
c.Auth = config.Auth{
|
|
Enabled: true, Store: path, SignupOpen: true,
|
|
CacheTTL: 50 * time.Millisecond,
|
|
}
|
|
})
|
|
return h, path
|
|
}
|
|
|
|
const password = "a long enough passphrase"
|
|
|
|
func TestAnAccountIsUselessUntilItIsApproved(t *testing.T) {
|
|
// The whole reason a public signup form is safe: it produces something that
|
|
// cannot do anything.
|
|
h, path := signupHarness(t)
|
|
b := newBrowser(t, h.router.URL)
|
|
|
|
code, body, _ := b.post("/signup", url.Values{
|
|
"email": {"ayse@example.com"}, "name": {"Ayse"}, "password": {password},
|
|
})
|
|
if code != http.StatusOK || !strings.Contains(body, "waiting for approval") {
|
|
t.Fatalf("signup returned %d: %s", code, body)
|
|
}
|
|
|
|
code, body, _ = b.post("/login", url.Values{
|
|
"email": {"ayse@example.com"}, "password": {password},
|
|
})
|
|
if code != http.StatusUnauthorized || !strings.Contains(body, "waiting for approval") {
|
|
t.Fatalf("a pending account signed in: %d", code)
|
|
}
|
|
|
|
// The profile page is not reachable either.
|
|
if code, _ := b.get("/profile"); code != http.StatusSeeOther {
|
|
t.Errorf("an unauthenticated visit to /profile returned %d", code)
|
|
}
|
|
|
|
// Approve, and it all works.
|
|
withStore(t, path, func(s *store.SQLite) {
|
|
users, err := s.Users(context.Background(), store.UserPending)
|
|
if err != nil || len(users) != 1 {
|
|
t.Fatalf("pending users: %v %v", users, err)
|
|
}
|
|
if err := s.ApproveUser(context.Background(), users[0].ID, "proj", "test", time.Now()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
})
|
|
|
|
code, _, loc := b.post("/login", url.Values{
|
|
"email": {"ayse@example.com"}, "password": {password},
|
|
})
|
|
if code != http.StatusSeeOther || loc != "/profile" {
|
|
t.Fatalf("sign-in after approval returned %d to %q", code, loc)
|
|
}
|
|
}
|
|
|
|
func TestAUserIssuesTheirOwnKeyAndItWorks(t *testing.T) {
|
|
h, path := signupHarness(t)
|
|
b := newBrowser(t, h.router.URL)
|
|
signUpAndApprove(t, b, path, "ayse@example.com")
|
|
|
|
_, profile := b.get("/profile")
|
|
token := csrf(t, profile)
|
|
|
|
code, body, _ := b.post("/profile/keys", url.Values{
|
|
"csrf": {token}, "name": {"laptop"},
|
|
})
|
|
if code != http.StatusOK {
|
|
t.Fatalf("creating a key returned %d", code)
|
|
}
|
|
key := extractKey(t, body)
|
|
|
|
// The key the person made for themselves is a real key.
|
|
if code, msg := h.call(t, key, testModel); code != http.StatusOK {
|
|
t.Fatalf("a self-issued key does not work: %d %s", code, msg)
|
|
}
|
|
|
|
// And it is listed afterwards, without the secret.
|
|
_, profile = b.get("/profile")
|
|
if !strings.Contains(profile, "laptop") {
|
|
t.Error("the key is not listed")
|
|
}
|
|
if strings.Contains(profile, key) {
|
|
t.Error("the profile page shows the key again; it is meant to be shown once")
|
|
}
|
|
}
|
|
|
|
func TestAUserCannotRevokeSomeoneElsesKey(t *testing.T) {
|
|
// The ownership check is in the statement rather than a prior read, so a
|
|
// guessed id from another account changes nothing.
|
|
h, path := signupHarness(t)
|
|
|
|
ayse := newBrowser(t, h.router.URL)
|
|
signUpAndApprove(t, ayse, path, "ayse@example.com")
|
|
_, p1 := ayse.get("/profile")
|
|
_, body, _ := ayse.post("/profile/keys", url.Values{"csrf": {csrf(t, p1)}, "name": {"ayse-key"}})
|
|
ayseKey := extractKey(t, body)
|
|
|
|
var ayseKeyID string
|
|
withStore(t, path, func(s *store.SQLite) {
|
|
users, _ := s.Users(context.Background(), store.UserActive)
|
|
for _, u := range users {
|
|
if u.Email == "ayse@example.com" {
|
|
keys, _ := s.KeysForUser(context.Background(), u.ID)
|
|
if len(keys) != 1 {
|
|
t.Fatalf("ayse has %d keys", len(keys))
|
|
}
|
|
ayseKeyID = keys[0].ID
|
|
}
|
|
}
|
|
})
|
|
|
|
mehmet := newBrowser(t, h.router.URL)
|
|
signUpAndApprove(t, mehmet, path, "mehmet@example.com")
|
|
_, p2 := mehmet.get("/profile")
|
|
|
|
if code, _, _ := mehmet.post("/profile/keys/"+ayseKeyID+"/revoke",
|
|
url.Values{"csrf": {csrf(t, p2)}}); code != http.StatusSeeOther {
|
|
t.Fatalf("status %d", code)
|
|
}
|
|
// It must still work.
|
|
if code, msg := h.call(t, ayseKey, testModel); code != http.StatusOK {
|
|
t.Errorf("someone else revoked this key: %d %s", code, msg)
|
|
}
|
|
}
|
|
|
|
func TestAFormWithoutItsTokenIsRefused(t *testing.T) {
|
|
// A cookie authenticates the browser, not the page that asked. Without this,
|
|
// any site the person visits can post here and have the browser attach the
|
|
// session for it.
|
|
h, path := signupHarness(t)
|
|
b := newBrowser(t, h.router.URL)
|
|
signUpAndApprove(t, b, path, "ayse@example.com")
|
|
|
|
for _, bad := range []url.Values{
|
|
{"name": {"x"}},
|
|
{"csrf": {""}, "name": {"x"}},
|
|
{"csrf": {"forged"}, "name": {"x"}},
|
|
} {
|
|
if code, _, _ := b.post("/profile/keys", bad); code != http.StatusBadRequest {
|
|
t.Errorf("a form with csrf=%q was accepted: %d", bad.Get("csrf"), code)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSigningOutEndsTheSession(t *testing.T) {
|
|
h, path := signupHarness(t)
|
|
b := newBrowser(t, h.router.URL)
|
|
signUpAndApprove(t, b, path, "ayse@example.com")
|
|
|
|
_, profile := b.get("/profile")
|
|
if _, _, _ = b.post("/logout", url.Values{"csrf": {csrf(t, profile)}}); false {
|
|
t.Fatal("unreachable")
|
|
}
|
|
if code, _ := b.get("/profile"); code != http.StatusSeeOther {
|
|
t.Errorf("the profile was still reachable after signing out: %d", code)
|
|
}
|
|
}
|
|
|
|
func TestSuspensionClosesOpenSessions(t *testing.T) {
|
|
h, path := signupHarness(t)
|
|
b := newBrowser(t, h.router.URL)
|
|
id := signUpAndApprove(t, b, path, "ayse@example.com")
|
|
|
|
if code, _ := b.get("/profile"); code != http.StatusOK {
|
|
t.Fatalf("profile before suspension: %d", code)
|
|
}
|
|
withStore(t, path, func(s *store.SQLite) {
|
|
if err := s.SetUserState(context.Background(), id, store.UserSuspended); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
})
|
|
if code, _ := b.get("/profile"); code != http.StatusSeeOther {
|
|
t.Errorf("a suspended account kept its session: %d", code)
|
|
}
|
|
}
|
|
|
|
func TestSignupCanBeClosed(t *testing.T) {
|
|
path, _ := provision(t)
|
|
h := start(t, 2, func(c *config.Server) {
|
|
c.Auth = config.Auth{Enabled: true, Store: path, SignupOpen: false}
|
|
})
|
|
b := newBrowser(t, h.router.URL)
|
|
|
|
if code, body := b.get("/signup"); code == http.StatusOK && strings.Contains(body, "<form") {
|
|
t.Errorf("the signup form is served although signup is closed: %d", code)
|
|
}
|
|
// The status the mux gives depends on which catch-all the path falls
|
|
// through to, which is not the point. What matters is that no account
|
|
// appears.
|
|
if code, _, _ := b.post("/signup", url.Values{
|
|
"email": {"a@example.com"}, "password": {password},
|
|
}); code == http.StatusOK || code == http.StatusSeeOther {
|
|
t.Errorf("signup accepted a post although it is closed: %d", code)
|
|
}
|
|
withStore(t, path, func(s *store.SQLite) {
|
|
users, err := s.Users(context.Background(), "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(users) != 0 {
|
|
t.Errorf("%d accounts exist although signup is closed", len(users))
|
|
}
|
|
})
|
|
}
|
|
|
|
// signUpAndApprove runs the operator's half and returns the new user's id.
|
|
func signUpAndApprove(t *testing.T, b *browser, path, email string) string {
|
|
t.Helper()
|
|
if code, _, _ := b.post("/signup", url.Values{
|
|
"email": {email}, "name": {email}, "password": {password},
|
|
}); code != http.StatusOK {
|
|
t.Fatalf("signup returned %d", code)
|
|
}
|
|
|
|
var id string
|
|
withStore(t, path, func(s *store.SQLite) {
|
|
users, err := s.Users(context.Background(), store.UserPending)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, u := range users {
|
|
if u.Email == email {
|
|
id = u.ID
|
|
}
|
|
}
|
|
if id == "" {
|
|
t.Fatalf("no pending account for %s", email)
|
|
}
|
|
if err := s.ApproveUser(context.Background(), id, "proj", "test", time.Now()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
})
|
|
|
|
if code, _, _ := b.post("/login", url.Values{
|
|
"email": {email}, "password": {password},
|
|
}); code != http.StatusSeeOther {
|
|
t.Fatalf("sign-in returned %d", code)
|
|
}
|
|
return id
|
|
}
|
|
|
|
func TestChangingAPasswordKeepsThisBrowserAndDropsTheOthers(t *testing.T) {
|
|
// Both halves matter. Signing every session out is the security property;
|
|
// keeping this one is what stops the person who just proved their password
|
|
// from being thrown back to the sign-in page.
|
|
h, path := signupHarness(t)
|
|
|
|
laptop := newBrowser(t, h.router.URL)
|
|
signUpAndApprove(t, laptop, path, "ayse@example.com")
|
|
|
|
// A second browser, signed in as the same person.
|
|
phone := newBrowser(t, h.router.URL)
|
|
if code, _, _ := phone.post("/login", url.Values{
|
|
"email": {"ayse@example.com"}, "password": {password},
|
|
}); code != http.StatusSeeOther {
|
|
t.Fatalf("second sign-in returned %d", code)
|
|
}
|
|
if code, _ := phone.get("/profile"); code != http.StatusOK {
|
|
t.Fatalf("the second browser was not signed in: %d", code)
|
|
}
|
|
|
|
_, profile := laptop.get("/profile")
|
|
const newPassword = "an entirely different passphrase"
|
|
code, body, _ := laptop.post("/profile/password", url.Values{
|
|
"csrf": {csrf(t, profile)}, "current": {password}, "new": {newPassword},
|
|
})
|
|
if code != http.StatusOK {
|
|
t.Fatalf("changing the password returned %d", code)
|
|
}
|
|
if !strings.Contains(body, "password was changed") {
|
|
t.Errorf("the page does not confirm the change")
|
|
}
|
|
|
|
// This browser is still signed in, and its forms still work — which they
|
|
// only do if the new CSRF token reached the page that was just rendered.
|
|
newToken := csrf(t, body)
|
|
if code, _, _ := laptop.post("/profile/keys", url.Values{
|
|
"csrf": {newToken}, "name": {"after-change"},
|
|
}); code != http.StatusOK {
|
|
t.Errorf("the form on the page after a password change was refused: %d", code)
|
|
}
|
|
|
|
// The other browser is not.
|
|
if code, _ := phone.get("/profile"); code != http.StatusSeeOther {
|
|
t.Errorf("the other browser kept its session: %d", code)
|
|
}
|
|
|
|
// And the old password is gone.
|
|
fresh := newBrowser(t, h.router.URL)
|
|
if code, _, _ := fresh.post("/login", url.Values{
|
|
"email": {"ayse@example.com"}, "password": {password},
|
|
}); code != http.StatusUnauthorized {
|
|
t.Errorf("the old password still signs in: %d", code)
|
|
}
|
|
if code, _, _ := fresh.post("/login", url.Values{
|
|
"email": {"ayse@example.com"}, "password": {newPassword},
|
|
}); code != http.StatusSeeOther {
|
|
t.Errorf("the new password does not sign in: %d", code)
|
|
}
|
|
}
|
|
|
|
func TestAWrongCurrentPasswordChangesNothing(t *testing.T) {
|
|
h, path := signupHarness(t)
|
|
b := newBrowser(t, h.router.URL)
|
|
signUpAndApprove(t, b, path, "ayse@example.com")
|
|
|
|
_, profile := b.get("/profile")
|
|
_, body, _ := b.post("/profile/password", url.Values{
|
|
"csrf": {csrf(t, profile)}, "current": {"wrong"}, "new": {"something else entirely"},
|
|
})
|
|
if !strings.Contains(body, "not your current password") {
|
|
t.Error("the page does not say why it was refused")
|
|
}
|
|
// Still signed in, still on the old password.
|
|
if code, _ := b.get("/profile"); code != http.StatusOK {
|
|
t.Errorf("a failed change signed the person out: %d", code)
|
|
}
|
|
}
|