Reject sessions issued before a password change.

A failed password read no longer mints a setup token, and filling the login limiter no longer drops an active lockout.
This commit is contained in:
protonmatter
2026-11-17 22:54:16 +01:00
committed by BaaRai
parent 8ae53f74cf
commit 26a7bbec37
6 changed files with 178 additions and 20 deletions
+90 -14
View File
@@ -19,13 +19,15 @@ import (
"golang.org/x/crypto/bcrypt"
"github.com/Autumn-27/artex/config"
"github.com/Autumn-27/artex/db"
)
const (
jwtKeyFilename = "jwt.key"
authPassKey = "auth.password_hash"
jwtTTL = 7 * 24 * time.Hour
keyChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
jwtKeyFilename = "jwt.key"
authPassKey = "auth.password_hash"
authPwdEpochKey = "auth.password_epoch"
jwtTTL = 7 * 24 * time.Hour
keyChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
// The lower bound matches the setup page's frontend validation — validation that
// lives only in the frontend is as good as none: hitting the API directly bypasses
@@ -167,15 +169,24 @@ func signJWT(key []byte) (string, error) {
}).SignedString(key)
}
// verifyJWT returns true when tokenStr is a valid, non-expired HS256 token.
func verifyJWT(tokenStr string, key []byte) bool {
t, err := jwt.Parse(tokenStr, func(t *jwt.Token) (any, error) {
// verifyJWT returns true when tokenStr is a valid, non-expired HS256 token
// issued at or after notBefore. notBefore is Unix seconds; 0 means no cutoff,
// so a deployment that has never stored a password epoch keeps existing sessions.
func verifyJWT(tokenStr string, key []byte, notBefore int64) bool {
claims := &jwt.RegisteredClaims{}
t, err := jwt.ParseWithClaims(tokenStr, claims, func(t *jwt.Token) (any, error) {
if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, fmt.Errorf("unexpected signing method")
}
return key, nil
})
return err == nil && t.Valid
if err != nil || !t.Valid {
return false
}
if notBefore > 0 && (claims.IssuedAt == nil || claims.IssuedAt.Unix() < notBefore) {
return false
}
return true
}
// jwtSubject returns the subject of tokenStr when it is a valid, non-expired
@@ -197,7 +208,11 @@ func jwtSubject(tokenStr string, key []byte) string {
// approver is who a human decision is recorded for: the subject of the
// request's session token.
func (s *Server) approver(r *http.Request) string {
return jwtSubject(extractToken(r), s.jwtKey)
tok := extractToken(r)
if !verifyJWT(tok, s.jwtKey, s.pwdEpoch.Load()) {
return ""
}
return jwtSubject(tok, s.jwtKey)
}
// extractToken reads the JWT from Authorization: Bearer header,
@@ -226,7 +241,7 @@ func (s *Server) requireAuth(h http.Handler) http.Handler {
writeErr(w, 401, "Unauthorized")
return
}
if !verifyJWT(tok, s.jwtKey) {
if !verifyJWT(tok, s.jwtKey, s.pwdEpoch.Load()) {
writeErr(w, 401, "token is invalid or expired")
return
}
@@ -258,15 +273,72 @@ func (s *Server) initSetupToken() {
if s.m == nil || s.m.pg == nil {
return
}
if hash, _, err := s.m.pg.GetSetting(authPassKey); err == nil && hash != "" {
var hash string
var err error
for attempt := 1; attempt <= 3; attempt++ {
var ok bool
hash, ok, err = s.m.pg.GetSetting(authPassKey)
if err == nil {
if ok && hash != "" {
return
}
break
}
log.Printf("[auth] password lookup attempt %d/3: %v", attempt, err)
if attempt < 3 {
time.Sleep(time.Duration(attempt) * 100 * time.Millisecond)
}
}
if err != nil {
log.Printf("[auth] password lookup failed; not issuing a setup token: %v", err)
return
}
buf := make([]byte, 16)
if _, err := rand.Read(buf); err != nil {
log.Fatalf("[auth] generate setup token: %v", err)
}
s.setupToken = hex.EncodeToString(buf)
log.Printf("[auth] no admin password is set. Setup token for the /setup page: %s", s.setupToken)
token := hex.EncodeToString(buf)
s.setupMu.Lock()
s.setupToken = token
s.setupMu.Unlock()
log.Printf("[auth] no admin password is set. Setup token for the /setup page: %s", token)
}
// loadPwdEpoch reads auth.password_epoch. A missing key leaves the cutoff at
// zero, which accepts every valid token.
func (s *Server) loadPwdEpoch() {
if s.m == nil || s.m.pg == nil {
return
}
raw, ok, err := s.m.pg.GetSetting(authPwdEpochKey)
if err != nil {
log.Printf("[auth] password epoch: %v", err)
return
}
if !ok || raw == "" {
return
}
n, err := strconv.ParseInt(raw, 10, 64)
if err != nil {
log.Printf("[auth] password epoch %q: %v", raw, err)
return
}
s.pwdEpoch.Store(n)
}
// bumpPwdEpoch records the current second as the oldest token that is still
// valid. A token signed in that same second still passes. A failed write leaves
// the previous cutoff in place and is logged; the password change itself stands.
func (s *Server) bumpPwdEpoch(pg *db.DB) {
if pg == nil {
return
}
epoch := time.Now().Unix()
if err := pg.SetSetting(authPwdEpochKey, strconv.FormatInt(epoch, 10)); err != nil {
log.Printf("[auth] save password epoch: %v", err)
return
}
s.pwdEpoch.Store(epoch)
}
// checkSetupToken compares got with the active setup token in constant time.
@@ -330,6 +402,7 @@ func (s *Server) authInit(w http.ResponseWriter, r *http.Request) {
s.setupMu.Lock()
s.setupToken = ""
s.setupMu.Unlock()
s.bumpPwdEpoch(pg)
tok, err := signJWT(s.jwtKey)
if err != nil {
writeErr(w, 500, "token generation failed")
@@ -346,7 +419,7 @@ func (s *Server) authChangePassword(w http.ResponseWriter, r *http.Request) {
if pg == nil {
return
}
if !verifyJWT(extractToken(r), s.jwtKey) {
if !verifyJWT(extractToken(r), s.jwtKey, s.pwdEpoch.Load()) {
writeErr(w, 401, "Unauthorized")
return
}
@@ -388,6 +461,9 @@ func (s *Server) authChangePassword(w http.ResponseWriter, r *http.Request) {
writeErr(w, 500, "Save failed: "+err.Error())
return
}
// Sessions issued before this second stop working. This response does not
// include a replacement token; the next request asks for a new login.
s.bumpPwdEpoch(pg)
writeJSON(w, 200, map[string]any{"ok": true})
}
+23
View File
@@ -0,0 +1,23 @@
package server
import (
"testing"
"time"
)
func TestTokenBeforePasswordEpochIsRejected(t *testing.T) {
key := []byte("0123456789abcdef0123456789abcdef")
tok, err := signJWT(key)
if err != nil {
t.Fatal(err)
}
if !verifyJWT(tok, key, 0) {
t.Fatal("a token with no password epoch must be accepted")
}
if verifyJWT(tok, key, time.Now().Add(time.Minute).Unix()) {
t.Fatal("a token issued before the password epoch must be rejected")
}
if !verifyJWT(tok, key, time.Now().Add(-time.Minute).Unix()) {
t.Fatal("a token issued after the password epoch must be accepted")
}
}
+22 -4
View File
@@ -105,16 +105,34 @@ func (l *loginLimiter) sweep(now time.Time) {
}
}
// evictOldest drops the least recently seen entry to stay under loginMaxEntries.
// evictOldest drops the least recently seen entry that is not inside a block.
// A block that is still running stays, so filling the map cannot clear an
// active lockout. When every entry is blocked, the one whose block ends soonest
// is the one that goes.
func (l *loginLimiter) evictOldest() {
now := l.now()
var oldest string
var at time.Time
found := false
for ip, e := range l.entries {
if oldest == "" || e.lastSeen.Before(at) {
oldest, at = ip, e.lastSeen
if now.Before(e.blockedUntil) {
continue
}
if !found || e.lastSeen.Before(at) {
oldest, at, found = ip, e.lastSeen, true
}
}
delete(l.entries, oldest)
if !found {
var until time.Time
for ip, e := range l.entries {
if oldest == "" || e.blockedUntil.Before(until) {
oldest, until = ip, e.blockedUntil
}
}
}
if oldest != "" {
delete(l.entries, oldest)
}
}
// peerIP is the host part of the TCP peer address.
+30
View File
@@ -274,6 +274,36 @@ func TestLoginLimiterCapsEntries(t *testing.T) {
}
}
func TestEvictOldestKeepsBlockedEntries(t *testing.T) {
clk := newFakeClock()
l := newLoginLimiter(clk.now)
now := clk.now()
l.entries["blocked"] = &loginEntry{lastSeen: now.Add(-2 * time.Hour), blockedUntil: now.Add(time.Hour), block: time.Minute}
l.entries["idle"] = &loginEntry{lastSeen: now.Add(-time.Hour)}
l.evictOldest()
if _, ok := l.entries["blocked"]; !ok {
t.Fatal("evicted a blocked address while an idle one existed")
}
if _, ok := l.entries["idle"]; ok {
t.Fatal("kept the idle address")
}
}
func TestEvictOldestDropsSoonestBlockWhenAllBlocked(t *testing.T) {
clk := newFakeClock()
l := newLoginLimiter(clk.now)
now := clk.now()
l.entries["long"] = &loginEntry{lastSeen: now, blockedUntil: now.Add(2 * time.Hour)}
l.entries["short"] = &loginEntry{lastSeen: now.Add(-time.Hour), blockedUntil: now.Add(time.Minute)}
l.evictOldest()
if _, ok := l.entries["short"]; ok {
t.Fatal("kept the block that ends sooner")
}
if _, ok := l.entries["long"]; !ok {
t.Fatal("evicted the longer block")
}
}
func TestHealthHidesVersionWithoutToken(t *testing.T) {
key := []byte("0123456789abcdef0123456789abcdef")
s := &Server{jwtKey: key}
+7 -1
View File
@@ -19,6 +19,7 @@ import (
"strconv"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/Autumn-27/artex/agent"
@@ -53,6 +54,10 @@ type Server struct {
setupMu sync.Mutex
setupToken string // one-time token POST /api/auth/init requires; empty when none is active
// pwdEpoch is auth.password_epoch in Unix seconds. Zero means the setting
// is absent and every valid token is accepted. A token issued before the
// stored second is rejected.
pwdEpoch atomic.Int64
loginLimit *loginLimiter // per-IP attempt limit on POST /api/auth/login
trustedProxies []netip.Prefix // ARTEX_TRUSTED_PROXIES; see clientIP
@@ -170,6 +175,7 @@ func New(ctx context.Context, m *Manager, skillDir string, dataDir string, keyDi
o(s)
}
s.initSetupToken()
s.loadPwdEpoch()
s.initSideQuestions()
// Circuit-breaker thresholds/cooldowns are hot parameters on the failure path; push the global retry policy to the Registry once at startup,
// and again on every policy save (saveLLMRetryPolicy).
@@ -1033,7 +1039,7 @@ func (s *Server) Handler() http.Handler {
// with a valid token gets the service name and version; the web UI's top bar
// reads the version, and sends its token.
func (s *Server) health(w http.ResponseWriter, r *http.Request) {
if !verifyJWT(extractToken(r), s.jwtKey) {
if !verifyJWT(extractToken(r), s.jwtKey, s.pwdEpoch.Load()) {
writeJSON(w, 200, map[string]any{"ok": true})
return
}
+6 -1
View File
@@ -181,7 +181,9 @@ export async function http<T>(path: string, init?: RequestInit): Promise<T> {
// to the Go backend on :8787, whose CORS is open.
//
// Override either default with NEXT_PUBLIC_SSE_BASE (set it to "" to force same-origin).
// Token is appended as ?token= because SSE can't carry cookies cross-origin.
// A same-origin stream sends the artex_token cookie. The query token is added only
// when base is non-empty, which is the dev connection to :8787: that origin cannot
// send the cookie.
// mockReport returns a canned Markdown report for the demo.
function mockReport(_task?: string): string {
return `# ARTEX Penetration Test Report — Acme Corp
@@ -211,6 +213,9 @@ export function sseUrl(path: string): string {
(process.env.NODE_ENV !== "production" && typeof window !== "undefined"
? `${window.location.protocol}//${window.location.hostname}:8787`
: "");
if (!base) {
return path;
}
const token = getToken();
const sep = path.includes("?") ? "&" : "?";
return token ? `${base}${path}${sep}token=${encodeURIComponent(token)}` : `${base}${path}`;