mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-19 06:30:54 +08:00
324 lines
10 KiB
Go
324 lines
10 KiB
Go
package server
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestPasswordVersionClaim(t *testing.T) {
|
|
key := []byte("0123456789abcdef0123456789abcdef")
|
|
legacy, err := signJWT(key)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
previous, err := signJWTVersion(key, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
current, err := signJWTVersion(key, 2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !verifyJWT(legacy, key, 0) {
|
|
t.Fatal("before any password change a token must be accepted")
|
|
}
|
|
if verifyJWT(legacy, key, 2) || verifyJWT(previous, key, 2) {
|
|
t.Fatal("a token from an older password version must be rejected")
|
|
}
|
|
if !verifyJWT(current, key, 2) {
|
|
t.Fatal("a token carrying the current version must be accepted")
|
|
}
|
|
// Two signatures in the same second still differ by version.
|
|
newest, err := signJWTVersion(key, 3)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if verifyJWT(current, key, 3) {
|
|
t.Fatal("two changes in the same second must not leave the older token valid")
|
|
}
|
|
if !verifyJWT(newest, key, 3) {
|
|
t.Fatal("the newest version must be accepted")
|
|
}
|
|
}
|
|
|
|
func TestChangePasswordRevokesOldTokenAndKeepsItWhenSaveFails(t *testing.T) {
|
|
m, err := NewManager(t.TempDir(), "")
|
|
if err != nil {
|
|
t.Skipf("postgres unavailable (%v)", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
stamp := time.Now().UnixNano()
|
|
s := &Server{
|
|
m: m,
|
|
jwtKey: []byte("0123456789abcdef0123456789abcdef"),
|
|
loginLimit: newLoginLimiter(time.Now),
|
|
authHashKey: fmt.Sprintf("test.password_hash.%d", stamp),
|
|
authVersionKey: fmt.Sprintf("test.password_version.%d", stamp),
|
|
}
|
|
t.Cleanup(func() {
|
|
_, _ = m.pg.Exec(`DELETE FROM settings WHERE key=$1 OR key=$2`, s.authHashKey, s.authVersionKey)
|
|
})
|
|
|
|
s.setupToken = "setup-ok"
|
|
initBody := `{"password":"correct-horse-1","setup_token":"setup-ok"}`
|
|
w := httptest.NewRecorder()
|
|
s.authInit(w, httptest.NewRequest("POST", "/api/auth/init", strings.NewReader(initBody)))
|
|
if w.Code != 200 {
|
|
t.Fatalf("init status=%d body=%s", w.Code, w.Body.String())
|
|
}
|
|
var issued struct {
|
|
Token string `json:"token"`
|
|
}
|
|
if err := json.Unmarshal(w.Body.Bytes(), &issued); err != nil || issued.Token == "" {
|
|
t.Fatalf("init token: %v body=%s", err, w.Body.String())
|
|
}
|
|
if !s.sessionOK(issued.Token) {
|
|
t.Fatal("token from init was rejected")
|
|
}
|
|
|
|
change := httptest.NewRequest("POST", "/api/auth/change-password", strings.NewReader(`{"old_password":"correct-horse-1","new_password":"correct-horse-2"}`))
|
|
change.Header.Set("Authorization", "Bearer "+issued.Token)
|
|
w = httptest.NewRecorder()
|
|
s.authChangePassword(w, change)
|
|
if w.Code != 200 {
|
|
t.Fatalf("change status=%d body=%s", w.Code, w.Body.String())
|
|
}
|
|
if s.sessionOK(issued.Token) {
|
|
t.Fatal("token from before the password change is still accepted")
|
|
}
|
|
|
|
w = httptest.NewRecorder()
|
|
s.authLogin(w, httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"username":"ARTEX","password":"correct-horse-2"}`)))
|
|
if w.Code != 200 {
|
|
t.Fatalf("login status=%d body=%s", w.Code, w.Body.String())
|
|
}
|
|
var logged struct {
|
|
Token string `json:"token"`
|
|
}
|
|
if err := json.Unmarshal(w.Body.Bytes(), &logged); err != nil || logged.Token == "" {
|
|
t.Fatalf("login token: %v body=%s", err, w.Body.String())
|
|
}
|
|
if !s.sessionOK(logged.Token) {
|
|
t.Fatal("replacement token was rejected")
|
|
}
|
|
|
|
reached := false
|
|
s.requireAuth(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
|
|
reached = true
|
|
})).ServeHTTP(httptest.NewRecorder(), requestWithToken("GET", "/api/tasks", issued.Token))
|
|
if reached {
|
|
t.Fatal("revoked token reached a protected handler")
|
|
}
|
|
|
|
if _, err := m.pg.Exec(`UPDATE settings SET value='not-a-number' WHERE key=$1`, s.authVersionKey); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
before := s.pwdVersion.Load()
|
|
fail := httptest.NewRequest("POST", "/api/auth/change-password", strings.NewReader(`{"old_password":"correct-horse-2","new_password":"correct-horse-3"}`))
|
|
fail.Header.Set("Authorization", "Bearer "+logged.Token)
|
|
w = httptest.NewRecorder()
|
|
s.authChangePassword(w, fail)
|
|
if w.Code != 500 {
|
|
t.Fatalf("failed save status=%d want 500 body=%s", w.Code, w.Body.String())
|
|
}
|
|
if s.pwdVersion.Load() != before {
|
|
t.Fatalf("version moved from %d to %d after a failed save", before, s.pwdVersion.Load())
|
|
}
|
|
if !s.sessionOK(logged.Token) {
|
|
t.Fatal("a failed save revoked the current token")
|
|
}
|
|
w = httptest.NewRecorder()
|
|
s.authLogin(w, httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"username":"ARTEX","password":"correct-horse-2"}`)))
|
|
if w.Code != 200 {
|
|
t.Fatalf("old password after a failed save: status=%d body=%s", w.Code, w.Body.String())
|
|
}
|
|
w = httptest.NewRecorder()
|
|
s.authLogin(w, httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"username":"ARTEX","password":"correct-horse-3"}`)))
|
|
if w.Code == 200 {
|
|
t.Fatal("new password was stored even though the version write failed")
|
|
}
|
|
}
|
|
|
|
func TestUnreadablePasswordVersionRejectsSessions(t *testing.T) {
|
|
m, err := NewManager(t.TempDir(), "")
|
|
if err != nil {
|
|
t.Skipf("postgres unavailable (%v)", err)
|
|
}
|
|
defer m.Close()
|
|
key := []byte("0123456789abcdef0123456789abcdef")
|
|
s := &Server{m: m, jwtKey: key, loginLimit: newLoginLimiter(time.Now)}
|
|
s.authVersionKey = fmt.Sprintf("test.password_version.%d", time.Now().UnixNano())
|
|
tok, err := signJWTVersion(key, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.applyPasswordVersion(1)
|
|
if !s.sessionOK(tok) {
|
|
t.Fatal("token was rejected before the read failed")
|
|
}
|
|
if err := m.pg.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.loadPasswordVersion()
|
|
if s.pwdState.Load() != pwdUnreadable {
|
|
t.Fatalf("state=%d want unreadable", s.pwdState.Load())
|
|
}
|
|
if s.sessionOK(tok) {
|
|
t.Fatal("accepted a token while the password version was unreadable")
|
|
}
|
|
w := httptest.NewRecorder()
|
|
req := httptest.NewRequest("POST", "/api/auth/change-password", strings.NewReader(`{"old_password":"correct-horse-1","new_password":"correct-horse-2"}`))
|
|
req.Header.Set("Authorization", "Bearer "+tok)
|
|
s.authChangePassword(w, req)
|
|
if w.Code != 401 {
|
|
t.Fatalf("change while unreadable: status=%d want 401 body=%s", w.Code, w.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestLoginRereadsPasswordVersionWhenUnreadable(t *testing.T) {
|
|
m, err := NewManager(t.TempDir(), "")
|
|
if err != nil {
|
|
t.Skipf("postgres unavailable (%v)", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
stamp := time.Now().UnixNano()
|
|
s := &Server{
|
|
m: m,
|
|
jwtKey: []byte("0123456789abcdef0123456789abcdef"),
|
|
loginLimit: newLoginLimiter(time.Now),
|
|
authHashKey: fmt.Sprintf("test.password_hash.%d", stamp),
|
|
authVersionKey: fmt.Sprintf("test.password_version.%d", stamp),
|
|
}
|
|
t.Cleanup(func() {
|
|
_, _ = m.pg.Exec(`DELETE FROM settings WHERE key=$1 OR key=$2`, s.authHashKey, s.authVersionKey)
|
|
})
|
|
s.setupToken = "setup-ok"
|
|
w := httptest.NewRecorder()
|
|
s.authInit(w, httptest.NewRequest("POST", "/api/auth/init", strings.NewReader(`{"password":"correct-horse-1","setup_token":"setup-ok"}`)))
|
|
if w.Code != 200 {
|
|
t.Fatalf("init status=%d body=%s", w.Code, w.Body.String())
|
|
}
|
|
if _, err := m.pg.Exec(`UPDATE settings SET value='not-a-number' WHERE key=$1`, s.authVersionKey); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.pwdVersion.Store(99)
|
|
s.loadPasswordVersion()
|
|
if s.pwdState.Load() != pwdUnreadable {
|
|
t.Fatalf("state=%d want unreadable", s.pwdState.Load())
|
|
}
|
|
w = httptest.NewRecorder()
|
|
s.authLogin(w, httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"username":"ARTEX","password":"correct-horse-1"}`)))
|
|
if w.Code != 503 {
|
|
t.Fatalf("login while unreadable: status=%d want 503 body=%s", w.Code, w.Body.String())
|
|
}
|
|
if s.pwdState.Load() != pwdUnreadable {
|
|
t.Fatal("a failed reread opened sessions")
|
|
}
|
|
|
|
if _, err := m.pg.Exec(`UPDATE settings SET value='1' WHERE key=$1`, s.authVersionKey); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w = httptest.NewRecorder()
|
|
s.authLogin(w, httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"username":"ARTEX","password":"correct-horse-1"}`)))
|
|
if w.Code != 200 {
|
|
t.Fatalf("login after the version can be read: status=%d body=%s", w.Code, w.Body.String())
|
|
}
|
|
if s.pwdState.Load() != pwdReady || s.pwdVersion.Load() != 1 {
|
|
t.Fatalf("state=%d version=%d, want ready at 1", s.pwdState.Load(), s.pwdVersion.Load())
|
|
}
|
|
var logged struct {
|
|
Token string `json:"token"`
|
|
}
|
|
if err := json.Unmarshal(w.Body.Bytes(), &logged); err != nil || logged.Token == "" {
|
|
t.Fatalf("login token: %v body=%s", err, w.Body.String())
|
|
}
|
|
if !s.sessionOK(logged.Token) {
|
|
t.Fatal("token from the healed login was rejected")
|
|
}
|
|
}
|
|
|
|
func TestAbsentPasswordVersionKeepsSessions(t *testing.T) {
|
|
m, err := NewManager(t.TempDir(), "")
|
|
if err != nil {
|
|
t.Skipf("postgres unavailable (%v)", err)
|
|
}
|
|
defer m.Close()
|
|
key := []byte("0123456789abcdef0123456789abcdef")
|
|
s := &Server{
|
|
m: m,
|
|
jwtKey: key,
|
|
authVersionKey: fmt.Sprintf("test.missing.version.%d", time.Now().UnixNano()),
|
|
}
|
|
s.loadPasswordVersion()
|
|
if s.pwdState.Load() != pwdReady || s.pwdVersion.Load() != 0 {
|
|
t.Fatalf("state=%d version=%d, want ready at 0", s.pwdState.Load(), s.pwdVersion.Load())
|
|
}
|
|
tok, err := signJWT(key)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !s.sessionOK(tok) {
|
|
t.Fatal("a token was rejected when no password version is stored")
|
|
}
|
|
}
|
|
|
|
func TestStreamLogsStopsWhenPasswordVersionChanges(t *testing.T) {
|
|
key := []byte("0123456789abcdef0123456789abcdef")
|
|
s := &Server{jwtKey: key}
|
|
s.applyPasswordVersion(1)
|
|
tok, err := signJWTVersion(key, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, cursor := logSink.recent(0, 1)
|
|
ready := make(chan struct{})
|
|
var once sync.Once
|
|
w := &flushNotify{ResponseWriter: httptest.NewRecorder(), notify: func() {
|
|
once.Do(func() { close(ready) })
|
|
}}
|
|
req := requestWithToken("GET", fmt.Sprintf("/api/logs/stream?since=%d", cursor), tok)
|
|
done := make(chan struct{})
|
|
go func() {
|
|
s.streamLogs(w, req)
|
|
close(done)
|
|
}()
|
|
select {
|
|
case <-ready:
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("log stream did not start")
|
|
}
|
|
s.applyPasswordVersion(2)
|
|
logSink.add(LogLine{Text: "after password change"})
|
|
select {
|
|
case <-done:
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("log stream stayed open after the password version changed")
|
|
}
|
|
}
|
|
|
|
func requestWithToken(method, target, token string) *http.Request {
|
|
r := httptest.NewRequest(method, target, nil)
|
|
r.Header.Set("Authorization", "Bearer "+token)
|
|
return r
|
|
}
|
|
|
|
type flushNotify struct {
|
|
http.ResponseWriter
|
|
notify func()
|
|
}
|
|
|
|
func (f *flushNotify) Flush() {
|
|
f.notify()
|
|
if fl, ok := f.ResponseWriter.(http.Flusher); ok {
|
|
fl.Flush()
|
|
}
|
|
}
|