整理前后端与测试构建目录并完善配置和安全引导
Security Checks / security (push) Waiting to run

统一 frontend、backend、test、test-log 和 out 目录,更新构建、部署及测试入口;纳入配置管理兼容与首次安全引导修复;排除本机配置、密钥和测试产物。
This commit is contained in:
xuans committed 2026-09-05 19:19:52 +08:00
1 parent 28cd9d3406
commit f60d3b0880
603 files changed
+2351 -660

No files matched your search

+72
View File
@@ -0,0 +1,72 @@
package verification
import (
"errors"
"sync"
"time"
)
var ErrCleanupAlreadyStarted = errors.New("verification cleanup already started")
type CleanupRunner struct {
store *Store
mu sync.Mutex
stop chan struct{}
done chan struct{}
stopping bool
}
func NewCleanupRunner(store *Store) *CleanupRunner {
return &CleanupRunner{store: store}
}
// Start 启动单实例过期清理器;验证码不会从持久化介质恢复。
func (r *CleanupRunner) Start(interval time.Duration) error {
if r == nil || r.store == nil || interval <= 0 {
return ErrInvalidChallenge
}
r.mu.Lock()
if r.stop != nil || r.stopping {
r.mu.Unlock()
return ErrCleanupAlreadyStarted
}
r.stop = make(chan struct{})
r.done = make(chan struct{})
stop, done := r.stop, r.done
r.mu.Unlock()
go func() {
ticker := time.NewTicker(interval)
defer ticker.Stop()
defer close(done)
for {
select {
case <-ticker.C:
r.store.Cleanup()
case <-stop:
return
}
}
}()
return nil
}
func (r *CleanupRunner) Stop() {
if r == nil {
return
}
r.mu.Lock()
stop, done := r.stop, r.done
if stop == nil || r.stopping {
r.mu.Unlock()
return
}
r.stopping = true
r.mu.Unlock()
if stop != nil {
close(stop)
<-done
}
r.mu.Lock()
r.stop, r.done, r.stopping = nil, nil, false
r.mu.Unlock()
}
@@ -0,0 +1,37 @@
package verification
import (
"testing"
"time"
)
func TestCleanupRunnerHasSingleInstance(t *testing.T) {
store, err := NewStore(4)
if err != nil {
t.Fatal(err)
}
runner := NewCleanupRunner(store)
if err := runner.Start(time.Hour); err != nil {
t.Fatal(err)
}
defer runner.Stop()
if err := runner.Start(time.Hour); err != ErrCleanupAlreadyStarted {
t.Fatalf("second cleanup runner start error = %v", err)
}
}
func TestCleanupRunnerCanRestartAfterStop(t *testing.T) {
store, err := NewStore(4)
if err != nil {
t.Fatal(err)
}
runner := NewCleanupRunner(store)
if err := runner.Start(time.Hour); err != nil {
t.Fatal(err)
}
runner.Stop()
if err := runner.Start(time.Hour); err != nil {
t.Fatalf("cleanup runner restart error = %v", err)
}
runner.Stop()
}
+181
View File
@@ -0,0 +1,181 @@
package verification
import (
"errors"
"fmt"
"mime"
"net"
"net/mail"
"net/smtp"
"strconv"
"strings"
smailsmtp "git.pcux.cn/xuans/Smail/utils/smtp"
)
type SecurityMode string
const (
SecurityStartTLS SecurityMode = "starttls"
SecurityImplicitTLS SecurityMode = "tls"
SecurityPlain SecurityMode = "plain"
)
var (
ErrInvalidSMTPConfig = errors.New("invalid SMTP configuration")
ErrUnsupportedSMTP = errors.New("unsupported SMTP security mode")
)
type SMTPSettings struct {
Host string
Port int
Username string
Password string
Security SecurityMode
From string
FromDomain string
}
type SMTPDelivery struct {
settings SMTPSettings
send func(SMTPSettings, string, []byte) error
}
func NewSMTPDelivery(settings SMTPSettings) (*SMTPDelivery, error) {
if err := validateSMTPSettings(settings); err != nil {
return nil, err
}
return &SMTPDelivery{settings: settings, send: sendSMTPMessage}, nil
}
func (d *SMTPDelivery) Delivery() Delivery {
return func(challenge Challenge, code string) error {
if d == nil || d.send == nil || challenge.Email == "" || code == "" {
return ErrInvalidChallenge
}
message := buildCodeMessage(d.settings.From, challenge.Email, code, challenge.Purpose)
defer clearBytes(message)
return d.send(d.settings, challenge.Email, message)
}
}
func IssueWithSMTP(store *Store, request IssueRequest, settings SMTPSettings) (Challenge, error) {
if store == nil {
return Challenge{}, ErrInvalidChallenge
}
delivery, err := NewSMTPDelivery(settings)
if err != nil {
return Challenge{}, err
}
return store.Issue(request, delivery.Delivery())
}
func validateSMTPSettings(settings SMTPSettings) error {
host := strings.TrimSpace(settings.Host)
if !isValidSMTPHost(host) {
return ErrInvalidSMTPConfig
}
from := strings.TrimSpace(settings.From)
parsedFrom, err := mail.ParseAddress(from)
if err != nil || parsedFrom.Address != from || strings.ContainsAny(from, "\r\n") {
return ErrInvalidSMTPConfig
}
if settings.Port <= 0 || settings.Port > 65535 {
return ErrInvalidSMTPConfig
}
switch settings.Security {
case SecurityStartTLS, SecurityImplicitTLS:
case SecurityPlain:
if !isLocalSMTPHost(host) {
return ErrInvalidSMTPConfig
}
default:
return ErrUnsupportedSMTP
}
if settings.Username == "" && settings.Password != "" {
return ErrInvalidSMTPConfig
}
return nil
}
func isLocalSMTPHost(host string) bool {
normalized := strings.TrimSuffix(strings.ToLower(strings.TrimSpace(host)), ".")
if normalized == "localhost" {
return true
}
ip := net.ParseIP(normalized)
return ip != nil && ip.IsLoopback()
}
func isValidSMTPHost(host string) bool {
if host == "" || strings.ContainsAny(host, "@/\\\r\n\t ") {
return false
}
if net.ParseIP(host) != nil {
return true
}
if strings.Contains(host, ":") {
return false
}
if len(host) > 253 || strings.HasPrefix(host, ".") || strings.HasSuffix(host, ".") {
return false
}
for _, label := range strings.Split(host, ".") {
if label == "" || len(label) > 63 || strings.HasPrefix(label, "-") || strings.HasSuffix(label, "-") {
return false
}
for _, r := range label {
if (r < 'a' || r > 'z') && (r < 'A' || r > 'Z') && (r < '0' || r > '9') && r != '-' {
return false
}
}
}
return true
}
func sendSMTPMessage(settings SMTPSettings, recipient string, message []byte) error {
addr := net.JoinHostPort(settings.Host, strconv.Itoa(settings.Port))
var auth smtp.Auth
if settings.Username != "" {
auth = smtp.PlainAuth("", settings.Username, settings.Password, settings.Host)
}
fromDomain := settings.FromDomain
if fromDomain == "" {
parts := strings.SplitN(settings.From, "@", 2)
if len(parts) == 2 {
fromDomain = parts[1]
}
}
switch settings.Security {
case SecurityStartTLS:
return smailsmtp.SendMail(settings.Host, addr, auth, settings.From, fromDomain, []string{recipient}, message)
case SecurityImplicitTLS:
return smailsmtp.SendMailWithTls(settings.Host, addr, auth, settings.From, fromDomain, []string{recipient}, message)
case SecurityPlain:
return smailsmtp.SendMailUnsafe(settings.Host, addr, auth, settings.From, fromDomain, []string{recipient}, message)
default:
return ErrUnsupportedSMTP
}
}
func buildCodeMessage(from, recipient string, code string, purpose Purpose) []byte {
title := "Smail 安全验证码"
purposeText := "完成本次安全验证"
switch purpose {
case PurposeLogin:
purposeText = "完成登录二次验证"
case PurposePasswordRecover:
purposeText = "完成密码恢复验证"
case PurposeExternalEmailBind:
purposeText = "完成外部邮箱绑定验证"
case PurposeExternalEmailChange:
purposeText = "完成外部邮箱变更验证"
}
return []byte(fmt.Sprintf("From: %s\r\nTo: %s\r\nSubject: %s\r\nContent-Type: text/plain; charset=UTF-8\r\n\r\n您好,您正在%s。验证码:%s\r\n验证码有效期为十分钟,请勿向他人泄露。\r\n", from, recipient, mime.QEncoding.Encode("UTF-8", title), purposeText, code))
}
func clearBytes(data []byte) {
for i := range data {
data[i] = 0
}
}
@@ -0,0 +1,73 @@
package verification
import (
"strings"
"testing"
)
func TestSupportedPurposes(t *testing.T) {
for _, purpose := range []Purpose{PurposeLogin, PurposePasswordRecover, PurposeExternalEmailBind, PurposeExternalEmailChange} {
if !IsSupportedPurpose(purpose) {
t.Fatalf("purpose %q was rejected", purpose)
}
}
if IsSupportedPurpose(Purpose("sensitive_operation")) {
t.Fatal("high risk operation purpose was accepted")
}
}
func TestSMTPDeliveryKeepsCodeOutOfChallenge(t *testing.T) {
settings := SMTPSettings{Host: "smtp.example.com", Port: 587, Security: SecurityStartTLS, From: "no-reply@example.com"}
delivery, err := NewSMTPDelivery(settings)
if err != nil {
t.Fatal(err)
}
var message []byte
delivery.send = func(_ SMTPSettings, _ string, data []byte) error {
message = append([]byte(nil), data...)
return nil
}
challenge := Challenge{ID: "challenge", Purpose: PurposeLogin, Account: "smail", Email: "user@example.com"}
if err := delivery.Delivery()(challenge, "123456"); err != nil {
t.Fatal(err)
}
if !strings.Contains(string(message), "123456") {
t.Fatal("verification code was not delivered")
}
if challenge.ID == "123456" || challenge.Account == "123456" {
t.Fatal("verification code leaked into challenge metadata")
}
clearBytes(message)
}
func TestSMTPModesAreValidated(t *testing.T) {
base := SMTPSettings{Host: "localhost", Port: 25, Security: SecurityPlain, From: "no-reply@example.com"}
if _, err := NewSMTPDelivery(base); err != nil {
t.Fatal(err)
}
base.Security = SecurityMode("unknown")
if _, err := NewSMTPDelivery(base); err != ErrUnsupportedSMTP {
t.Fatalf("unexpected error: %v", err)
}
base.Security = SecurityPlain
base.Host = "smtp.example.com"
if _, err := NewSMTPDelivery(base); err != ErrInvalidSMTPConfig {
t.Fatalf("remote plaintext SMTP was accepted: %v", err)
}
}
func TestSMTPHostValidation(t *testing.T) {
base := SMTPSettings{Host: "smtp.example.com", Port: 587, Security: SecurityStartTLS, From: "no-reply@example.com"}
for _, host := range []string{"smtp.example.com", "127.0.0.1", "2001:db8::1"} {
base.Host = host
if _, err := NewSMTPDelivery(base); err != nil {
t.Fatalf("host %q rejected: %v", host, err)
}
}
for _, host := range []string{"", "smtp.example.com:587", "user@smtp.example.com", "smtp example.com", "-smtp.example.com", "smtp..example.com"} {
base.Host = host
if _, err := NewSMTPDelivery(base); err != ErrInvalidSMTPConfig {
t.Fatalf("host %q error = %v, want invalid configuration", host, err)
}
}
}
@@ -0,0 +1,108 @@
package verification
import (
"context"
"sync"
"time"
)
const DefaultOperationalCleanupInterval = time.Hour
type OperationalCleanupRunner struct {
mu sync.Mutex
store *EventStore
rateLimits *PersistentRateLimiter
interval time.Duration
running bool
stopping bool
stop chan struct{}
done chan struct{}
now func() time.Time
}
func NewOperationalCleanupRunner(store *EventStore, rateLimits ...*PersistentRateLimiter) *OperationalCleanupRunner {
runner := &OperationalCleanupRunner{store: store, interval: DefaultOperationalCleanupInterval, now: time.Now}
if len(rateLimits) > 0 {
runner.rateLimits = rateLimits[0]
}
return runner
}
func (r *OperationalCleanupRunner) Start() {
if r == nil || r.store == nil {
return
}
r.mu.Lock()
if r.running || r.stopping {
r.mu.Unlock()
return
}
r.running = true
r.stop = make(chan struct{})
r.done = make(chan struct{})
stop, done := r.stop, r.done
interval := r.interval
r.mu.Unlock()
go func() {
defer close(done)
r.runOnce()
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
r.runOnce()
case <-stop:
return
}
}
}()
}
func (r *OperationalCleanupRunner) Stop() {
if r == nil {
return
}
r.mu.Lock()
stop, done := r.stop, r.done
if stop == nil {
r.mu.Unlock()
return
}
r.stop, r.done, r.running = nil, nil, false
r.stopping = true
r.mu.Unlock()
close(stop)
<-done
r.mu.Lock()
r.stop, r.done, r.stopping = nil, nil, false
r.mu.Unlock()
}
func (r *OperationalCleanupRunner) runOnce() {
if r == nil || r.store == nil {
return
}
now := time.Now()
if r.now != nil {
now = r.now()
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
lease, acquired, err := r.store.TryAcquireCleanupLease(ctx, now)
if err != nil || !acquired {
return
}
if _, err = r.store.Cleanup(ctx, now); err == nil && r.rateLimits != nil {
_, err = r.rateLimits.Cleanup(ctx, now)
}
if err != nil {
_ = r.store.FailCleanup(ctx, lease, now)
_ = r.store.Record(EventInput{Purpose: PurposeLogin, Action: "cleanup", Outcome: "failure"})
return
}
_ = r.store.FinishCleanup(ctx, lease, now)
_ = r.store.Record(EventInput{Purpose: PurposeLogin, Action: "cleanup", Outcome: "success"})
}
@@ -0,0 +1,123 @@
package verification
import (
"context"
"path/filepath"
"strings"
"sync"
"testing"
"time"
"git.pcux.cn/xuans/Smail/models"
_ "modernc.org/sqlite"
"xorm.io/xorm"
)
func newCleanupEngine(t *testing.T) *xorm.Engine {
t.Helper()
engine, err := xorm.NewEngine("sqlite", filepath.Join(t.TempDir(), "cleanup.db"))
if err != nil {
t.Fatal(err)
}
if err := engine.Sync2(&models.VerificationEvent{}, &models.VerificationCleanupState{}, &models.VerificationRateLimit{}); err != nil {
_ = engine.Close()
t.Fatal(err)
}
return engine
}
func TestCleanupLeaseIsSingleInstanceAndHasPersistedSchedule(t *testing.T) {
engine := newCleanupEngine(t)
defer engine.Close()
store, err := NewEventStore(engine)
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 8, 26, 8, 0, 0, 0, time.UTC)
lease, acquired, err := store.TryAcquireCleanupLease(context.Background(), now)
if err != nil || !acquired || lease.Token == "" {
t.Fatalf("first lease = %+v, %v, %v", lease, acquired, err)
}
if _, acquired, err := store.TryAcquireCleanupLease(context.Background(), now); err != nil || acquired {
t.Fatalf("second instance acquired active lease: %v, %v", acquired, err)
}
if err := store.FinishCleanup(context.Background(), lease, now); err != nil {
t.Fatal(err)
}
if _, acquired, err := store.TryAcquireCleanupLease(context.Background(), now.Add(cleanupScheduleInterval-time.Second)); err != nil || acquired {
t.Fatalf("cleanup ran before persisted schedule: %v, %v", acquired, err)
}
second, acquired, err := store.TryAcquireCleanupLease(context.Background(), now.Add(cleanupScheduleInterval))
if err != nil || !acquired || second.Token == "" {
t.Fatalf("scheduled cleanup was not due: %+v, %v, %v", second, acquired, err)
}
}
func TestOperationalCleanupRunnerCanRestartAfterStop(t *testing.T) {
engine := newCleanupEngine(t)
defer engine.Close()
store, err := NewEventStore(engine)
if err != nil {
t.Fatal(err)
}
runner := NewOperationalCleanupRunner(store)
runner.Start()
runner.Stop()
runner.Start()
runner.Stop()
}
func TestCleanupFailureSchedulesSixHourRetry(t *testing.T) {
engine := newCleanupEngine(t)
defer engine.Close()
store, err := NewEventStore(engine)
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 8, 26, 8, 0, 0, 0, time.UTC)
lease, acquired, err := store.TryAcquireCleanupLease(context.Background(), now)
if err != nil || !acquired {
t.Fatal(err)
}
if err := store.FailCleanup(context.Background(), lease, now); err != nil {
t.Fatal(err)
}
if _, acquired, err := store.TryAcquireCleanupLease(context.Background(), now.Add(cleanupRetryInterval-time.Second)); err != nil || acquired {
t.Fatalf("cleanup retry started too early: %v, %v", acquired, err)
}
if _, acquired, err := store.TryAcquireCleanupLease(context.Background(), now.Add(cleanupRetryInterval)); err != nil || !acquired {
t.Fatalf("cleanup retry was not scheduled: %v, %v", acquired, err)
}
}
func TestCleanupStateInsertQueryUsesPostgresPlaceholders(t *testing.T) {
query := cleanupStateInsertQuery("postgres")
if !strings.Contains(query, "VALUES ($1, $2, $3, $4, $5, $6)") {
t.Fatalf("postgres cleanup query = %q", query)
}
if strings.Contains(query, "VALUES (, ") {
t.Fatalf("postgres cleanup query contains empty placeholders: %q", query)
}
}
func TestOperationalCleanupRunnerStopIsIdempotentAndConcurrentSafe(t *testing.T) {
engine := newCleanupEngine(t)
defer engine.Close()
store, err := NewEventStore(engine)
if err != nil {
t.Fatal(err)
}
runner := NewOperationalCleanupRunner(store)
runner.Start()
var wg sync.WaitGroup
for i := 0; i < 8; i++ {
wg.Add(1)
go func() {
defer wg.Done()
runner.Stop()
}()
}
wg.Wait()
runner.Stop()
}
@@ -0,0 +1,300 @@
package verification
import (
"context"
"crypto/hmac"
"crypto/rand"
"crypto/sha256"
"errors"
"fmt"
"strings"
"time"
"git.pcux.cn/xuans/Smail/models"
"xorm.io/xorm"
)
const (
OperationalRetention = 14 * 24 * time.Hour
DetailRetention = 30 * 24 * time.Hour
AggregateRetention = 90 * 24 * time.Hour
AuditRetention = 365 * 24 * time.Hour
CleanupBatchSize = 1000
)
const (
RetentionClassDetail = "detail"
RetentionClassAggregate = "aggregate"
RetentionClassAudit = "audit"
)
var (
ErrEventStoreUnavailable = errors.New("verification event store unavailable")
ErrInvalidEvent = errors.New("verification event is invalid")
)
const cleanupStateKey = "verification_event"
const cleanupLeaseDuration = 30 * time.Minute
const cleanupRetryInterval = 6 * time.Hour
const cleanupScheduleInterval = 14 * 24 * time.Hour
type cleanupLease struct {
Token string
}
type EventInput struct {
UserID int
Purpose Purpose
Action string
Outcome string
Account string
Email string
RemoteIP string
RetentionClass string
InvestigationHold bool
}
type EventStore struct {
engine *xorm.Engine
key [32]byte
now func() time.Time
}
func NewEventStore(engine *xorm.Engine) (*EventStore, error) {
if engine == nil {
return nil, ErrEventStoreUnavailable
}
store := &EventStore{engine: engine, now: time.Now}
if _, err := rand.Read(store.key[:]); err != nil {
return nil, fmt.Errorf("generate verification event key: %w", err)
}
return store, nil
}
func (s *EventStore) Record(input EventInput) error {
if s == nil || s.engine == nil || !IsSupportedPurpose(input.Purpose) || !isEventValue(input.Action) || !isEventValue(input.Outcome) {
return ErrInvalidEvent
}
if input.UserID < 0 {
return ErrInvalidEvent
}
now := s.now().UTC()
retentionClass := strings.ToLower(strings.TrimSpace(input.RetentionClass))
if retentionClass == "" {
retentionClass = RetentionClassDetail
}
retention, ok := retentionDuration(retentionClass)
if !ok {
return ErrInvalidEvent
}
event := models.VerificationEvent{
UserID: input.UserID,
Purpose: string(input.Purpose),
Action: input.Action,
Outcome: input.Outcome,
AccountFingerprint: s.fingerprint(input.Account),
EmailFingerprint: s.fingerprint(strings.ToLower(strings.TrimSpace(input.Email))),
IPFingerprint: s.fingerprint(strings.TrimSpace(input.RemoteIP)),
ExpiresAt: now.Add(retention),
RetentionClass: retentionClass,
InvestigationHold: input.InvestigationHold,
CreatedAt: now,
}
if event.AccountFingerprint == "" {
event.AccountFingerprint = ""
}
_, err := s.engine.Insert(&event)
if err != nil {
return fmt.Errorf("record verification event: %w", err)
}
return nil
}
func (s *EventStore) Cleanup(ctx context.Context, now time.Time) (int, error) {
if s == nil || s.engine == nil {
return 0, ErrEventStoreUnavailable
}
if now.IsZero() {
now = s.now()
}
cutoff := now.UTC()
deleted := 0
for {
select {
case <-ctx.Done():
return deleted, ctx.Err()
default:
}
var events []models.VerificationEvent
if err := s.engine.Where("expires_at < ? AND investigation_hold = ?", cutoff, false).
OrderBy("id asc").Limit(CleanupBatchSize).Find(&events); err != nil {
return deleted, fmt.Errorf("load expired verification events: %w", err)
}
if len(events) == 0 {
return deleted, nil
}
ids := make([]int, 0, len(events))
for _, event := range events {
ids = append(ids, event.ID)
}
count, err := s.engine.In("id", ids).Delete(&models.VerificationEvent{})
if err != nil {
return deleted, fmt.Errorf("delete expired verification events: %w", err)
}
deleted += int(count)
if len(events) < CleanupBatchSize {
return deleted, nil
}
}
}
func retentionDuration(class string) (time.Duration, bool) {
switch class {
case RetentionClassDetail:
return DetailRetention, true
case RetentionClassAggregate:
return AggregateRetention, true
case RetentionClassAudit:
return AuditRetention, true
default:
return 0, false
}
}
func (s *EventStore) fingerprint(value string) string {
if strings.TrimSpace(value) == "" {
return ""
}
mac := hmac.New(sha256.New, s.key[:])
_, _ = mac.Write([]byte(value))
return fmt.Sprintf("v1:%x", mac.Sum(nil))
}
func isEventValue(value string) bool {
value = strings.TrimSpace(value)
return value != "" && len(value) <= 32 && !strings.ContainsAny(value, "\r\n")
}
// TryAcquireCleanupLease 使用数据库事务竞争清理租约,确保同一环境只有一个清理实例。
func (s *EventStore) TryAcquireCleanupLease(ctx context.Context, now time.Time) (cleanupLease, bool, error) {
if s == nil || s.engine == nil {
return cleanupLease{}, false, ErrEventStoreUnavailable
}
if ctx == nil {
ctx = context.Background()
}
if now.IsZero() {
now = s.now()
}
session := s.engine.NewSession().Context(ctx)
if err := session.Begin(); err != nil {
return cleanupLease{}, false, fmt.Errorf("begin cleanup lease transaction: %w", err)
}
rollback := func(err error) (cleanupLease, bool, error) {
_ = session.Rollback()
return cleanupLease{}, false, err
}
if err := insertCleanupState(session, now); err != nil {
return rollback(fmt.Errorf("initialize cleanup state: %w", err))
}
query := session.Where("state_key = ?", cleanupStateKey)
if s.engine.DriverName() != "sqlite3" && s.engine.DriverName() != "sqlite" {
query = query.ForUpdate()
}
var state models.VerificationCleanupState
has, err := query.Get(&state)
if err != nil {
return rollback(fmt.Errorf("load cleanup state: %w", err))
}
if !has {
return rollback(ErrEventStoreUnavailable)
}
if state.LeaseUntil.After(now) || state.NextRunAt.After(now) {
if err := session.Rollback(); err != nil {
return cleanupLease{}, false, err
}
return cleanupLease{}, false, nil
}
token, err := randomID()
if err != nil {
return rollback(fmt.Errorf("generate cleanup lease token: %w", err))
}
state.LeaseToken = token
state.LeaseUntil = now.Add(cleanupLeaseDuration).UTC()
state.UpdatedAt = now.UTC()
if _, err := session.Where("state_key = ?", cleanupStateKey).Cols("lease_until", "lease_token", "updated_at").Update(&state); err != nil {
return rollback(fmt.Errorf("claim cleanup lease: %w", err))
}
if err := session.Commit(); err != nil {
return cleanupLease{}, false, fmt.Errorf("commit cleanup lease: %w", err)
}
return cleanupLease{Token: token}, true, nil
}
// FinishCleanup 标记本次清理成功,并安排下一次 14 天周期任务。
func (s *EventStore) FinishCleanup(ctx context.Context, lease cleanupLease, now time.Time) error {
return s.updateCleanupState(ctx, lease, now, false)
}
// FailCleanup 标记本次清理失败,并安排 6 小时后的重试。
func (s *EventStore) FailCleanup(ctx context.Context, lease cleanupLease, now time.Time) error {
return s.updateCleanupState(ctx, lease, now, true)
}
func (s *EventStore) updateCleanupState(ctx context.Context, lease cleanupLease, now time.Time, failed bool) error {
if s == nil || s.engine == nil {
return ErrEventStoreUnavailable
}
if strings.TrimSpace(lease.Token) == "" {
return ErrInvalidEvent
}
if ctx == nil {
ctx = context.Background()
}
if now.IsZero() {
now = s.now()
}
state := models.VerificationCleanupState{StateKey: cleanupStateKey}
has, err := s.engine.Context(ctx).Where("state_key = ? AND lease_token = ?", cleanupStateKey, lease.Token).Get(&state)
if err != nil {
return fmt.Errorf("load cleanup lease: %w", err)
}
if !has {
return ErrInvalidEvent
}
state.LeaseUntil = now.UTC()
state.LeaseToken = ""
state.UpdatedAt = now.UTC()
if failed {
state.FailureCount++
state.NextRunAt = now.Add(cleanupRetryInterval).UTC()
} else {
state.FailureCount = 0
state.NextRunAt = now.Add(cleanupScheduleInterval).UTC()
}
if _, err := s.engine.Context(ctx).Where("state_key = ? AND lease_token = ?", cleanupStateKey, lease.Token).Cols("next_run_at", "lease_until", "lease_token", "failure_count", "updated_at").Update(&state); err != nil {
return fmt.Errorf("update cleanup state: %w", err)
}
return nil
}
func insertCleanupState(session *xorm.Session, now time.Time) error {
if session == nil || session.Engine() == nil {
return ErrEventStoreUnavailable
}
epoch := time.Unix(0, 0).UTC()
query := cleanupStateInsertQuery(session.Engine().DriverName())
_, err := session.Exec(query, cleanupStateKey, now.UTC(), epoch, "", 0, now.UTC())
return err
}
func cleanupStateInsertQuery(driver string) string {
const columns = "(state_key, next_run_at, lease_until, lease_token, failure_count, updated_at)"
switch driver {
case "mysql":
return "INSERT IGNORE INTO verification_cleanup_state " + columns + " VALUES (?, ?, ?, ?, ?, ?)"
case "postgres":
return "INSERT INTO verification_cleanup_state " + columns + " VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT (state_key) DO NOTHING"
default:
return "INSERT OR IGNORE INTO verification_cleanup_state " + columns + " VALUES (?, ?, ?, ?, ?, ?)"
}
}
@@ -0,0 +1,116 @@
package verification
import (
"context"
"path/filepath"
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Smail/models"
_ "modernc.org/sqlite"
"xorm.io/xorm"
)
func TestEventStorePersistsOnlyOperationalFingerprintsAndCleansAfterRetention(t *testing.T) {
engine, err := xorm.NewEngine("sqlite", filepath.Join(t.TempDir(), "events.db"))
if err != nil {
t.Fatal(err)
}
defer engine.Close()
if err := engine.Sync2(&models.VerificationEvent{}); err != nil {
t.Fatal(err)
}
store, err := NewEventStore(engine)
if err != nil {
t.Fatal(err)
}
old := time.Now().UTC().Add(-DetailRetention - time.Hour)
store.now = func() time.Time { return old }
if err := store.Record(EventInput{
UserID: 7,
Purpose: PurposePasswordRecover,
Action: models.VerificationActionIssue,
Outcome: models.VerificationOutcomeSuccess,
Account: "smail",
Email: "owner@example.com",
RemoteIP: "127.0.0.1",
}); err != nil {
t.Fatal(err)
}
var raw string
if _, err := engine.SQL("SELECT account_fingerprint || '|' || email_fingerprint || '|' || ip_fingerprint FROM verification_event").Get(&raw); err != nil {
t.Fatal(err)
}
if raw == "" || strings.Contains(raw, "owner@example.com") || strings.Contains(raw, "smail") || strings.Contains(raw, "127.0.0.1") {
t.Fatalf("sensitive operational value was persisted: %q", raw)
}
deleted, err := store.Cleanup(context.Background(), old.Add(DetailRetention+time.Hour))
if err != nil {
t.Fatal(err)
}
if deleted != 1 {
t.Fatalf("deleted = %d, want 1", deleted)
}
}
func TestEventStoreRejectsUnsupportedPurpose(t *testing.T) {
engine, err := xorm.NewEngine("sqlite", filepath.Join(t.TempDir(), "events.db"))
if err != nil {
t.Fatal(err)
}
defer engine.Close()
store, err := NewEventStore(engine)
if err != nil {
t.Fatal(err)
}
if err := store.Record(EventInput{Purpose: Purpose("high_risk")}); err != ErrInvalidEvent {
t.Fatalf("error = %v, want invalid event", err)
}
}
func TestEventStoreKeepsInvestigationHoldAndSupportsRetentionClasses(t *testing.T) {
engine, err := xorm.NewEngine("sqlite", filepath.Join(t.TempDir(), "retention.db"))
if err != nil {
t.Fatal(err)
}
defer engine.Close()
if err := engine.Sync2(&models.VerificationEvent{}); err != nil {
t.Fatal(err)
}
store, err := NewEventStore(engine)
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 8, 26, 8, 0, 0, 0, time.UTC)
store.now = func() time.Time { return now }
if err := store.Record(EventInput{Purpose: PurposeLogin, Action: models.VerificationActionIssue, Outcome: models.VerificationOutcomeSuccess, RetentionClass: RetentionClassAudit, InvestigationHold: true}); err != nil {
t.Fatal(err)
}
if err := store.Record(EventInput{Purpose: PurposeLogin, Action: models.VerificationActionVerify, Outcome: models.VerificationOutcomeFailure, RetentionClass: RetentionClassAggregate}); err != nil {
t.Fatal(err)
}
var held, aggregate models.VerificationEvent
if _, err := engine.Where("investigation_hold = ?", true).Get(&held); err != nil {
t.Fatal(err)
}
if held.RetentionClass != RetentionClassAudit || !held.ExpiresAt.Equal(now.Add(AuditRetention)) {
t.Fatalf("held retention = %+v", held)
}
if _, err := engine.Where("retention_class = ?", RetentionClassAggregate).Get(&aggregate); err != nil {
t.Fatal(err)
}
deleted, err := store.Cleanup(context.Background(), now.Add(AuditRetention+time.Hour))
if err != nil {
t.Fatal(err)
}
if deleted != 1 {
t.Fatalf("deleted = %d, want aggregate event only", deleted)
}
var remaining int
if _, err := engine.SQL("SELECT COUNT(*) FROM verification_event").Get(&remaining); err != nil {
t.Fatal(err)
}
if remaining != 1 {
t.Fatalf("remaining events = %d, want held event", remaining)
}
}
+249
View File
@@ -0,0 +1,249 @@
package verification
import (
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"net"
"net/netip"
"strings"
"sync"
"time"
"git.pcux.cn/xuans/Smail/models"
"xorm.io/xorm"
)
const (
RateLimitDimensionAccount = "account"
RateLimitDimensionEmail = "email"
RateLimitDimensionIP = "ip"
RateLimitDimensionUser = "user"
RateLimitDimensionPurpose = "purpose"
RateLimitDimensionTransaction = "transaction"
RateLimitDimensionEnvironment = "environment"
RateLimitDimensionCredential = "credential"
PersistentRateLimitStateRetention = 30 * 24 * time.Hour
)
var ErrRateLimitStoreUnavailable = errors.New("verification rate limit store unavailable")
type RateLimitRequest struct {
Account string
Email string
RemoteIP string
UserID int
Purpose Purpose
BrowserTransaction string
Environment string
CredentialVersion int
}
type rateLimitDimension struct {
typ string
value string
hourLimit int
dayLimit int
}
// PersistentRateLimiter 使用数据库事务保存限流计数,数据库中只保存哈希后的维度键。
type PersistentRateLimiter struct {
engine *xorm.Engine
mu sync.Mutex
now func() time.Time
}
func NewPersistentRateLimiter(engine *xorm.Engine) (*PersistentRateLimiter, error) {
if engine == nil {
return nil, ErrRateLimitStoreUnavailable
}
return &PersistentRateLimiter{engine: engine, now: time.Now}, nil
}
func (r *PersistentRateLimiter) Allow(ctx context.Context, request RateLimitRequest, now time.Time) (bool, error) {
if r == nil || r.engine == nil {
return false, ErrRateLimitStoreUnavailable
}
if ctx == nil {
ctx = context.Background()
}
if now.IsZero() {
now = r.now()
}
dimensions := buildRateLimitDimensions(request)
if len(dimensions) == 0 {
return false, ErrRateLimitStoreUnavailable
}
// SQLite 使用单连接和数据库锁,MySQL/PostgreSQL 通过行锁保证跨进程原子更新。
r.mu.Lock()
defer r.mu.Unlock()
session := r.engine.NewSession().Context(ctx)
if err := session.Begin(); err != nil {
return false, fmt.Errorf("begin verification rate limit transaction: %w", err)
}
rollback := func(err error) (bool, error) {
_ = session.Rollback()
return false, err
}
rows := make([]models.VerificationRateLimit, 0, len(dimensions))
for _, dimension := range dimensions {
key := hashRateLimitKey(dimension.typ, dimension.value)
if err := insertRateLimitRow(session, key, dimension.typ, now); err != nil {
return rollback(fmt.Errorf("initialize verification rate limit: %w", err))
}
var row models.VerificationRateLimit
query := session.Where("dimension_key = ?", key)
if r.engine.DriverName() != "sqlite3" && r.engine.DriverName() != "sqlite" {
query = query.ForUpdate()
}
has, err := query.Get(&row)
if err != nil {
return rollback(fmt.Errorf("load verification rate limit: %w", err))
}
if !has {
return rollback(ErrRateLimitStoreUnavailable)
}
if !rateLimitRowAllowed(row, now, dimension.hourLimit, dimension.dayLimit) {
return rollback(nil)
}
rows = append(rows, row)
}
for i, dimension := range dimensions {
row := rows[i]
updated := now.UTC()
if row.HourStartedAt == nil || now.Sub(*row.HourStartedAt) >= issueWindow {
row.HourStartedAt = timePtr(now)
row.HourCount = 0
}
if row.DayStartedAt == nil || now.Sub(*row.DayStartedAt) >= issueDaily {
row.DayStartedAt = timePtr(now)
row.DayCount = 0
}
row.HourCount++
row.DayCount++
row.LastIssuedAt = timePtr(now)
row.ExpiresAt = updated.Add(PersistentRateLimitStateRetention)
row.UpdatedAt = updated
if _, err := session.ID(row.ID).Cols("hour_started_at", "hour_count", "day_started_at", "day_count", "last_issued_at", "expires_at", "updated_at").Update(&row); err != nil {
return rollback(fmt.Errorf("update verification rate limit %s: %w", dimension.typ, err))
}
}
if err := session.Commit(); err != nil {
return false, fmt.Errorf("commit verification rate limit transaction: %w", err)
}
return true, nil
}
func (r *PersistentRateLimiter) Cleanup(ctx context.Context, now time.Time) (int, error) {
if r == nil || r.engine == nil {
return 0, ErrRateLimitStoreUnavailable
}
if now.IsZero() {
now = r.now()
}
cutoff := now.UTC()
result, err := r.engine.Context(ctx).Where("expires_at < ?", cutoff).Delete(&models.VerificationRateLimit{})
if err != nil {
return 0, fmt.Errorf("cleanup verification rate limits: %w", err)
}
return int(result), nil
}
func buildRateLimitDimensions(request RateLimitRequest) []rateLimitDimension {
account := strings.ToLower(strings.TrimSpace(request.Account))
email := strings.ToLower(strings.TrimSpace(request.Email))
remoteIP := normalizeRateLimitIP(request.RemoteIP)
purpose := strings.ToLower(strings.TrimSpace(string(request.Purpose)))
environment := strings.TrimSpace(request.Environment)
if environment == "" {
environment = "default"
}
scope := func(value string) string {
return environment + "\x00" + value
}
dimensions := make([]rateLimitDimension, 0, 8)
appendDimension := func(typ, value string, hourLimit, dayLimit int) {
if strings.TrimSpace(value) != "" {
dimensions = append(dimensions, rateLimitDimension{typ: typ, value: value, hourLimit: hourLimit, dayLimit: dayLimit})
}
}
appendDimension(RateLimitDimensionAccount, scope(account), maxPerHour, maxPerDay)
appendDimension(RateLimitDimensionEmail, scope(email), maxPerHour, maxPerDay)
appendDimension(RateLimitDimensionIP, scope(remoteIP), maxPerIPHour, maxPerIPDay)
if request.UserID > 0 {
appendDimension(RateLimitDimensionUser, scope(fmt.Sprintf("%d", request.UserID)), maxPerHour, maxPerDay)
}
if purpose != "" && account != "" {
appendDimension(RateLimitDimensionPurpose, scope(purpose+"\x00"+account), maxPerHour, maxPerDay)
}
if transaction := strings.TrimSpace(request.BrowserTransaction); transaction != "" {
appendDimension(RateLimitDimensionTransaction, scope(transaction), maxPerHour, maxPerDay)
}
if request.CredentialVersion > 0 && account != "" {
appendDimension(RateLimitDimensionCredential, scope(fmt.Sprintf("%d\x00%s", request.CredentialVersion, account)), maxPerHour, maxPerDay)
}
return dimensions
}
func hashRateLimitKey(typ, value string) string {
hash := sha256.New()
_, _ = hash.Write([]byte("smail:verification-rate-limit:v1:"))
_, _ = hash.Write([]byte(typ))
_, _ = hash.Write([]byte{0})
_, _ = hash.Write([]byte(value))
return hex.EncodeToString(hash.Sum(nil))
}
func rateLimitRowAllowed(row models.VerificationRateLimit, now time.Time, hourLimit, dayLimit int) bool {
if row.LastIssuedAt != nil && now.Sub(*row.LastIssuedAt) < issueInterval {
return false
}
hourCount := row.HourCount
if row.HourStartedAt == nil || now.Sub(*row.HourStartedAt) >= issueWindow {
hourCount = 0
}
dayCount := row.DayCount
if row.DayStartedAt == nil || now.Sub(*row.DayStartedAt) >= issueDaily {
dayCount = 0
}
return hourCount < hourLimit && dayCount < dayLimit
}
func insertRateLimitRow(session *xorm.Session, key, typ string, now time.Time) error {
var query string
switch session.Engine().DriverName() {
case "mysql":
query = "INSERT IGNORE INTO verification_rate_limit (dimension_key, dimension_type, expires_at, updated_at) VALUES (?, ?, ?, ?)"
case "postgres":
query = "INSERT INTO verification_rate_limit (dimension_key, dimension_type, expires_at, updated_at) VALUES ($1, $2, $3, $4) ON CONFLICT (dimension_key) DO NOTHING"
default:
query = "INSERT OR IGNORE INTO verification_rate_limit (dimension_key, dimension_type, expires_at, updated_at) VALUES (?, ?, ?, ?)"
}
updated := now.UTC()
_, err := session.Exec(query, key, typ, updated.Add(PersistentRateLimitStateRetention), updated)
return err
}
func normalizeRateLimitIP(value string) string {
value = strings.TrimSpace(value)
if value == "" {
return ""
}
if host, _, err := net.SplitHostPort(value); err == nil {
value = host
} else {
value = strings.Trim(value, "[]")
}
if address, err := netip.ParseAddr(value); err == nil {
return address.Unmap().String()
}
return strings.ToLower(value)
}
func timePtr(value time.Time) *time.Time {
value = value.UTC()
return &value
}
@@ -0,0 +1,126 @@
package verification
import (
"context"
"errors"
"path/filepath"
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Smail/models"
_ "modernc.org/sqlite"
"xorm.io/xorm"
)
func newRateLimitEngine(t *testing.T) *xorm.Engine {
t.Helper()
engine, err := xorm.NewEngine("sqlite", filepath.Join(t.TempDir(), "rate-limit.db"))
if err != nil {
t.Fatal(err)
}
if err := engine.Sync2(&models.VerificationRateLimit{}); err != nil {
_ = engine.Close()
t.Fatal(err)
}
return engine
}
func TestPersistentRateLimiterSurvivesServiceRestart(t *testing.T) {
engine := newRateLimitEngine(t)
defer engine.Close()
limiter, err := NewPersistentRateLimiter(engine)
if err != nil {
t.Fatal(err)
}
first, err := NewStore(32)
if err != nil {
t.Fatal(err)
}
second, err := NewStore(32)
if err != nil {
t.Fatal(err)
}
service1, err := NewService(first, func(_ Challenge, _ string) error { return nil }, nil)
if err != nil {
t.Fatal(err)
}
service2, err := NewService(second, func(_ Challenge, _ string) error { return nil }, nil)
if err != nil {
t.Fatal(err)
}
service1.SetRateLimitStore(limiter)
service2.SetRateLimitStore(limiter)
now := time.Date(2026, 8, 26, 10, 0, 0, 0, time.UTC)
service1.now = func() time.Time { return now }
service2.now = func() time.Time { return now }
for i := 0; i < maxPerHour; i++ {
if _, err := service1.Issue(IssueRequest{Purpose: PurposeLogin, Account: "smail", Email: "owner@example.com", TTL: time.Second}, "[2001:0db8::1]:443"); err != nil {
t.Fatalf("issue %d: %v", i, err)
}
now = now.Add(issueInterval)
}
if _, err := service2.Issue(IssueRequest{Purpose: PurposeLogin, Account: "smail", Email: "owner@example.com"}, "2001:db8::1"); !errors.Is(err, ErrRateLimited) {
t.Fatalf("persistent account limit was bypassed after restart: %v", err)
}
if _, err := limiter.Cleanup(context.Background(), now); err != nil {
t.Fatal(err)
}
}
func TestPersistentRateLimiterAppliesIPLimitAcrossIdentities(t *testing.T) {
engine := newRateLimitEngine(t)
defer engine.Close()
limiter, err := NewPersistentRateLimiter(engine)
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 8, 26, 12, 0, 0, 0, time.UTC)
for i := 0; i < maxPerIPHour; i++ {
allowed, err := limiter.Allow(context.Background(), RateLimitRequest{
Account: "user-" + string(rune('a'+i)),
Email: "user-" + string(rune('a'+i)) + "@example.com",
RemoteIP: "192.0.2.10",
Purpose: PurposeLogin,
}, now)
if err != nil || !allowed {
t.Fatalf("allow %d = %v, %v", i, allowed, err)
}
now = now.Add(issueInterval)
}
allowed, err := limiter.Allow(context.Background(), RateLimitRequest{Account: "other", Email: "other@example.com", RemoteIP: "192.0.2.10", Purpose: PurposePasswordRecover}, now)
if err != nil {
t.Fatal(err)
}
if allowed {
t.Fatal("IP limit was bypassed by changing account, email, and purpose")
}
}
func TestPersistentRateLimiterDoesNotPersistSensitiveValues(t *testing.T) {
engine := newRateLimitEngine(t)
defer engine.Close()
limiter, err := NewPersistentRateLimiter(engine)
if err != nil {
t.Fatal(err)
}
if _, err := limiter.Allow(context.Background(), RateLimitRequest{Account: "smail", Email: "owner@example.com", RemoteIP: "127.0.0.1", Purpose: PurposePasswordRecover}, time.Now()); err != nil {
t.Fatal(err)
}
var raw string
if _, err := engine.SQL("SELECT dimension_key || '|' || dimension_type FROM verification_rate_limit").Get(&raw); err != nil {
t.Fatal(err)
}
if raw == "" || containsAny(raw, "smail", "owner@example.com", "127.0.0.1") {
t.Fatalf("sensitive value persisted: %q", raw)
}
}
func containsAny(value string, values ...string) bool {
for _, item := range values {
if strings.Contains(value, item) {
return true
}
}
return false
}
+62
View File
@@ -0,0 +1,62 @@
package verification
import (
"time"
"xorm.io/xorm"
)
const DefaultCleanupInterval = time.Minute
type Runtime struct {
Store *Store
Events *EventStore
RateLimits *PersistentRateLimiter
cleanup *CleanupRunner
operationalCleanup *OperationalCleanupRunner
}
func NewRuntime(maxEntries int) (*Runtime, error) {
return NewRuntimeWithEventStore(maxEntries, nil)
}
func NewRuntimeWithEventStore(maxEntries int, engine *xorm.Engine) (*Runtime, error) {
store, err := NewStore(maxEntries)
if err != nil {
return nil, err
}
runtime := &Runtime{Store: store, cleanup: NewCleanupRunner(store)}
if engine != nil {
events, eventErr := NewEventStore(engine)
if eventErr != nil {
return nil, eventErr
}
runtime.Events = events
rateLimits, limitErr := NewPersistentRateLimiter(engine)
if limitErr != nil {
return nil, limitErr
}
runtime.RateLimits = rateLimits
runtime.operationalCleanup = NewOperationalCleanupRunner(events, rateLimits)
runtime.operationalCleanup.Start()
}
if err := runtime.cleanup.Start(DefaultCleanupInterval); err != nil {
if runtime.operationalCleanup != nil {
runtime.operationalCleanup.Stop()
}
return nil, err
}
return runtime, nil
}
func (r *Runtime) Stop() {
if r == nil {
return
}
if r.cleanup != nil {
r.cleanup.Stop()
}
if r.operationalCleanup != nil {
r.operationalCleanup.Stop()
}
}
@@ -0,0 +1,14 @@
package verification
import "testing"
func TestRuntimeStartsWithInMemoryStore(t *testing.T) {
runtime, err := NewRuntime(8)
if err != nil {
t.Fatal(err)
}
if runtime.Store == nil || runtime.Store.Size() != 0 {
t.Fatal("runtime did not create an empty in-memory store")
}
runtime.Stop()
}
+211
View File
@@ -0,0 +1,211 @@
package verification
import (
"context"
"errors"
"fmt"
"strings"
"sync"
"time"
"git.pcux.cn/xuans/Smail/models"
)
var (
ErrRateLimited = errors.New("verification request rate limited")
ErrServiceDown = errors.New("verification service unavailable")
)
const (
issueInterval = time.Minute
issueWindow = time.Hour
issueDaily = 24 * time.Hour
maxPerHour = 5
maxPerDay = 10
maxPerIPHour = 20
maxPerIPDay = 20
)
type Service struct {
Store *Store
Events *EventStore
Send Delivery
RateLimits *PersistentRateLimiter
mu sync.Mutex
limits map[string]issueCounter
now func() time.Time
}
type issueCounter struct {
last time.Time
hour time.Time
hourN int
day time.Time
dayN int
}
func NewService(store *Store, send Delivery, events *EventStore) (*Service, error) {
if store == nil || send == nil {
return nil, ErrServiceDown
}
return &Service{Store: store, Send: send, Events: events, limits: make(map[string]issueCounter), now: time.Now}, nil
}
func (s *Service) SetRateLimitStore(store *PersistentRateLimiter) {
if s == nil {
return
}
s.RateLimits = store
}
func (s *Service) Issue(request IssueRequest, remoteIP string) (Challenge, error) {
if s == nil || s.Store == nil || s.Send == nil || !IsSupportedPurpose(request.Purpose) {
return Challenge{}, ErrServiceDown
}
request.Account = strings.TrimSpace(request.Account)
request.Email = strings.ToLower(strings.TrimSpace(request.Email))
if request.Account == "" || request.Email == "" {
return Challenge{}, ErrInvalidChallenge
}
allowed, limitErr := s.allow(request, remoteIP)
if limitErr != nil {
s.record(EventInput{Purpose: request.Purpose, Action: models.VerificationActionIssue, Outcome: models.VerificationOutcomeFailure, Account: request.Account, Email: request.Email, RemoteIP: remoteIP})
return Challenge{}, ErrServiceDown
}
if !allowed {
s.record(EventInput{Purpose: request.Purpose, Action: models.VerificationActionIssue, Outcome: models.VerificationOutcomeBlocked, Account: request.Account, Email: request.Email, RemoteIP: remoteIP})
return Challenge{}, ErrRateLimited
}
challenge, err := s.Store.Issue(request, s.Send)
if err != nil {
s.record(EventInput{Purpose: request.Purpose, Action: models.VerificationActionIssue, Outcome: models.VerificationOutcomeFailure, Account: request.Account, Email: request.Email, RemoteIP: remoteIP})
return Challenge{}, err
}
s.record(EventInput{Purpose: request.Purpose, Action: models.VerificationActionIssue, Outcome: models.VerificationOutcomeSuccess, Account: request.Account, Email: request.Email, RemoteIP: remoteIP})
return challenge, nil
}
func (s *Service) Verify(id, account, email, code string, purpose Purpose, remoteIP string) error {
return s.VerifyBound(id, account, email, code, purpose, 0, remoteIP)
}
func (s *Service) VerifyWithContext(id, account, email, code string, purpose Purpose, remoteIP, browserContext string) error {
return s.verifyBound(id, account, email, code, purpose, 0, remoteIP, browserContext)
}
// VerifyBound 验证绑定到具体业务资源的验证码,避免跨资源复用挑战。
func (s *Service) VerifyBound(id, account, email, code string, purpose Purpose, resourceID int, remoteIP string) error {
return s.verifyBound(id, account, email, code, purpose, resourceID, remoteIP, "")
}
func (s *Service) VerifyBoundWithContext(id, account, email, code string, purpose Purpose, resourceID int, remoteIP, browserContext string) error {
return s.verifyBound(id, account, email, code, purpose, resourceID, remoteIP, browserContext)
}
func (s *Service) verifyBound(id, account, email, code string, purpose Purpose, resourceID int, remoteIP, browserContext string) error {
if s == nil || s.Store == nil || !IsSupportedPurpose(purpose) {
return ErrServiceDown
}
err := s.Store.VerifyBoundWithContext(id, account, email, code, purpose, resourceID, browserContext)
outcome := models.VerificationOutcomeSuccess
if err != nil {
outcome = models.VerificationOutcomeFailure
}
s.record(EventInput{Purpose: purpose, Action: models.VerificationActionVerify, Outcome: outcome, Account: account, Email: email, RemoteIP: remoteIP})
return err
}
func (s *Service) record(input EventInput) {
if s == nil || s.Events == nil {
return
}
_ = s.Events.Record(input)
}
func (s *Service) allow(request IssueRequest, remoteIP string) (bool, error) {
now := s.now()
if s.RateLimits != nil {
allowed, err := s.RateLimits.Allow(context.Background(), RateLimitRequest{
Account: request.Account, Email: request.Email, RemoteIP: remoteIP,
UserID: request.UserID, Purpose: request.Purpose,
BrowserTransaction: request.BrowserTransaction,
Environment: request.Environment, CredentialVersion: request.CredentialVersion,
}, now)
if err != nil {
return false, err
}
if !allowed {
return false, nil
}
}
s.mu.Lock()
defer s.mu.Unlock()
keys := []string{"account:" + strings.ToLower(strings.TrimSpace(request.Account)), "email:" + strings.ToLower(strings.TrimSpace(request.Email))}
if remoteIP = strings.TrimSpace(remoteIP); remoteIP != "" {
keys = append(keys, "ip:"+remoteIP)
}
if len(s.limits) > 10000 {
for key, value := range s.limits {
if now.Sub(value.last) > issueDaily {
delete(s.limits, key)
}
}
}
for _, key := range keys {
hourLimit, dayLimit := keyLimit(key)
if !counterAllowed(s.limits[key], now, hourLimit, dayLimit) {
return false, nil
}
}
for _, key := range keys {
item := s.limits[key]
if item.hour.IsZero() || now.Sub(item.hour) >= issueWindow {
item.hour = now
item.hourN = 0
}
if item.day.IsZero() || now.Sub(item.day) >= issueDaily {
item.day = now
item.dayN = 0
}
item.last = now
item.hourN++
item.dayN++
s.limits[key] = item
}
return true, nil
}
func keyLimit(key string) (int, int) {
if strings.HasPrefix(key, "ip:") {
return maxPerIPHour, maxPerIPDay
}
return maxPerHour, maxPerDay
}
func counterAllowed(item issueCounter, now time.Time, limits ...int) bool {
hourLimit, dayLimit := maxPerHour, maxPerDay
if len(limits) > 0 && limits[0] > 0 {
hourLimit = limits[0]
}
if len(limits) > 1 && limits[1] > 0 {
dayLimit = limits[1]
}
if !item.last.IsZero() && now.Sub(item.last) < issueInterval {
return false
}
hourN := item.hourN
dayN := item.dayN
if item.hour.IsZero() || now.Sub(item.hour) >= issueWindow {
hourN = 0
}
if item.day.IsZero() || now.Sub(item.day) >= issueDaily {
dayN = 0
}
return hourN < hourLimit && dayN < dayLimit
}
func (s *Service) String() string {
if s == nil {
return ""
}
return fmt.Sprintf("verification service with %d active rate limit keys", len(s.limits))
}
@@ -0,0 +1,116 @@
package verification
import (
"errors"
"fmt"
"testing"
"time"
)
func TestServiceIssuesVerifiesAndAppliesMultiDimensionCooldown(t *testing.T) {
store, err := NewStore(8)
if err != nil {
t.Fatal(err)
}
var code string
service, err := NewService(store, func(_ Challenge, issued string) error {
code = issued
return nil
}, nil)
if err != nil {
t.Fatal(err)
}
fixed := time.Date(2026, 8, 25, 12, 0, 0, 0, time.UTC)
service.now = func() time.Time { return fixed }
challenge, err := service.Issue(IssueRequest{Purpose: PurposeLogin, Account: "smail", Email: "user@example.com"}, "127.0.0.1")
if err != nil {
t.Fatal(err)
}
if err := service.Verify(challenge.ID, "smail", "user@example.com", code, PurposeLogin, "127.0.0.1"); err != nil {
t.Fatal(err)
}
if _, err := service.Issue(IssueRequest{Purpose: PurposeLogin, Account: "smail", Email: "user@example.com"}, "127.0.0.1"); !errors.Is(err, ErrRateLimited) {
t.Fatalf("second issue error = %v", err)
}
}
func TestServiceRequiresDelivery(t *testing.T) {
store, err := NewStore(4)
if err != nil {
t.Fatal(err)
}
if _, err := NewService(store, nil, nil); !errors.Is(err, ErrServiceDown) {
t.Fatalf("error = %v", err)
}
}
func TestServiceAppliesIndependentAccountEmailAndIPLimits(t *testing.T) {
store, err := NewStore(64)
if err != nil {
t.Fatal(err)
}
service, err := NewService(store, func(_ Challenge, _ string) error { return nil }, nil)
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 8, 25, 12, 0, 0, 0, time.UTC)
service.now = func() time.Time { return now }
for i := 0; i < maxPerIPHour; i++ {
if _, err := service.Issue(IssueRequest{Purpose: PurposeLogin, Account: "user", Email: "one@example.com", TTL: time.Second}, "192.0.2.1"); err != nil {
if i == 0 || !errors.Is(err, ErrRateLimited) {
t.Fatalf("issue %d error = %v", i, err)
}
}
now = now.Add(issueInterval)
}
if _, err := service.Issue(IssueRequest{Purpose: PurposeLogin, Account: "user", Email: "two@example.com"}, "192.0.2.2"); !errors.Is(err, ErrRateLimited) {
t.Fatalf("account limit was bypassed by changing email and IP: %v", err)
}
}
func TestServiceAppliesIPLimitAcrossAccounts(t *testing.T) {
store, err := NewStore(128)
if err != nil {
t.Fatal(err)
}
service, err := NewService(store, func(_ Challenge, _ string) error { return nil }, nil)
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 8, 25, 12, 0, 0, 0, time.UTC)
service.now = func() time.Time { return now }
for i := 0; i < maxPerIPHour; i++ {
if _, err := service.Issue(IssueRequest{Purpose: PurposeLogin, Account: fmt.Sprintf("user-%d", i), Email: fmt.Sprintf("user-%d@example.com", i), TTL: time.Second}, "192.0.2.10"); err != nil {
t.Fatal(err)
}
now = now.Add(issueInterval)
}
if _, err := service.Issue(IssueRequest{Purpose: PurposeLogin, Account: "another", Email: "another@example.com"}, "192.0.2.10"); !errors.Is(err, ErrRateLimited) {
t.Fatalf("IP limit was bypassed by changing account and email: %v", err)
}
}
func TestServiceBindsVerificationToResource(t *testing.T) {
store, err := NewStore(8)
if err != nil {
t.Fatal(err)
}
var code string
service, err := NewService(store, func(_ Challenge, issued string) error {
code = issued
return nil
}, nil)
if err != nil {
t.Fatal(err)
}
challenge, err := service.Issue(IssueRequest{Purpose: PurposeExternalEmailBind, Account: "smail", Email: "user@example.com", ResourceID: 10}, "192.0.2.30")
if err != nil {
t.Fatal(err)
}
if err := service.VerifyBound(challenge.ID, "smail", "user@example.com", code, PurposeExternalEmailBind, 11, "192.0.2.30"); !errors.Is(err, ErrInvalidChallenge) {
t.Fatalf("cross-resource verification error = %v", err)
}
if err := service.VerifyBound(challenge.ID, "smail", "user@example.com", code, PurposeExternalEmailBind, 10, "192.0.2.30"); err != nil {
t.Fatalf("bound verification failed: %v", err)
}
}
+418
View File
@@ -0,0 +1,418 @@
package verification
import (
"crypto/hmac"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/hex"
"errors"
"fmt"
"io"
"strings"
"sync"
"time"
)
var (
ErrInvalidChallenge = errors.New("verification challenge is invalid")
ErrExpiredChallenge = errors.New("verification challenge is expired")
ErrTooManyAttempts = errors.New("verification challenge attempts exceeded")
ErrCapacityExceeded = errors.New("verification challenge capacity exceeded")
)
const (
DefaultCodeLength = 8
DefaultTTL = 10 * time.Minute
DefaultMaxEntries = 10000
DefaultMaxPerUser = 4
DefaultMaxAttempts = 5
)
type Purpose string
const (
PurposeLogin Purpose = "login"
PurposePasswordRecover Purpose = "password_recover"
PurposeExternalEmailBind Purpose = "external_email_bind"
PurposeExternalEmailChange Purpose = "external_email_change"
)
type Challenge struct {
ID string
Purpose Purpose
Account string
Email string
ResourceID int
IssuedAt time.Time
ExpiresAt time.Time
Attempts int
MaxAttempts int
}
type IssueRequest struct {
Purpose Purpose
Account string
Email string
UserID int
BrowserTransaction string
Environment string
CredentialVersion int
ResourceID int
TTL time.Duration
MaxAttempts int
}
type Delivery func(challenge Challenge, code string) error
type entry struct {
challenge Challenge
mac [32]byte
browserContextDigest [32]byte
hasBrowserContextDigest bool
}
type Store struct {
mu sync.Mutex
key [32]byte
entries map[string]entry
active map[string]string
perUser map[string]int
maxEntries int
maxPerUser int
codeLength int
maxAttempts int
now func() time.Time
}
func NewStore(maxEntries int) (*Store, error) {
if maxEntries <= 0 {
maxEntries = DefaultMaxEntries
}
store := &Store{
entries: make(map[string]entry),
active: make(map[string]string),
perUser: make(map[string]int),
maxEntries: maxEntries,
maxPerUser: DefaultMaxPerUser,
codeLength: DefaultCodeLength,
maxAttempts: DefaultMaxAttempts,
now: time.Now,
}
if _, err := rand.Read(store.key[:]); err != nil {
return nil, fmt.Errorf("generate verification process key: %w", err)
}
return store, nil
}
func (s *Store) Issue(request IssueRequest, delivery Delivery) (Challenge, error) {
if s == nil || delivery == nil || !IsSupportedPurpose(request.Purpose) || strings.TrimSpace(request.Account) == "" || strings.TrimSpace(request.Email) == "" {
return Challenge{}, ErrInvalidChallenge
}
if request.TTL <= 0 {
request.TTL = DefaultTTL
}
if request.MaxAttempts <= 0 || request.MaxAttempts > s.maxAttempts {
request.MaxAttempts = s.maxAttempts
}
now := s.now()
code, err := randomCode(s.codeLength)
if err != nil {
return Challenge{}, err
}
defer clearString(&code)
id, err := randomID()
if err != nil {
return Challenge{}, err
}
account := strings.TrimSpace(request.Account)
email := strings.TrimSpace(strings.ToLower(request.Email))
browserContext := strings.TrimSpace(request.BrowserTransaction)
var browserContextDigest [32]byte
if browserContext != "" {
browserContextDigest = sha256.Sum256([]byte(browserContext))
}
challenge := Challenge{
ID: id,
Purpose: request.Purpose,
Account: account,
Email: email,
ResourceID: request.ResourceID,
IssuedAt: now,
ExpiresAt: now.Add(request.TTL),
MaxAttempts: request.MaxAttempts,
}
s.mu.Lock()
s.cleanupLocked(now)
activeKey := challengeKey(account, request.Purpose)
if previousID := s.active[activeKey]; previousID != "" {
s.deleteLocked(previousID)
}
if len(s.entries) >= s.maxEntries || s.perUser[account] >= s.maxPerUser {
s.mu.Unlock()
return Challenge{}, ErrCapacityExceeded
}
mac := hmac.New(sha256.New, s.key[:])
_, _ = mac.Write([]byte(challenge.ID))
_, _ = mac.Write([]byte{0})
_, _ = mac.Write([]byte(challenge.Purpose))
_, _ = mac.Write([]byte{0})
_, _ = mac.Write([]byte(challenge.Account))
_, _ = mac.Write([]byte{0})
_, _ = mac.Write([]byte(challenge.Email))
_, _ = mac.Write([]byte{0})
_, _ = mac.Write([]byte(fmt.Sprintf("%d", challenge.ResourceID)))
_, _ = mac.Write([]byte{0})
_, _ = mac.Write(browserContextDigest[:])
_, _ = mac.Write([]byte{0})
_, _ = mac.Write([]byte(code))
var digest [32]byte
copy(digest[:], mac.Sum(nil))
s.entries[challenge.ID] = entry{challenge: challenge, mac: digest, browserContextDigest: browserContextDigest, hasBrowserContextDigest: browserContext != ""}
s.active[activeKey] = challenge.ID
s.perUser[account]++
s.mu.Unlock()
if err := delivery(challenge, code); err != nil {
s.mu.Lock()
s.deleteLocked(challenge.ID)
s.mu.Unlock()
return Challenge{}, err
}
return challenge, nil
}
// IsSupportedPurpose 保证验证码只能用于已确认的业务流程。
func IsSupportedPurpose(purpose Purpose) bool {
switch purpose {
case PurposeLogin, PurposePasswordRecover, PurposeExternalEmailBind, PurposeExternalEmailChange:
return true
default:
return false
}
}
func (s *Store) Verify(id, account, email, code string, purpose Purpose) error {
return s.VerifyBound(id, account, email, code, purpose, 0)
}
// VerifyBound 验证并原子消费绑定到具体业务资源的验证码。
func (s *Store) VerifyBound(id, account, email, code string, purpose Purpose, resourceID int) error {
return s.VerifyBoundWithContext(id, account, email, code, purpose, resourceID, "")
}
func (s *Store) VerifyBoundWithContext(id, account, email, code string, purpose Purpose, resourceID int, browserContext string) error {
if s == nil || strings.TrimSpace(id) == "" || strings.TrimSpace(account) == "" || strings.TrimSpace(email) == "" || strings.TrimSpace(code) == "" || purpose == "" {
return ErrInvalidChallenge
}
now := s.now()
s.mu.Lock()
defer s.mu.Unlock()
s.cleanupLocked(now)
item, ok := s.entries[id]
if !ok || item.challenge.Purpose != purpose || item.challenge.Account != strings.TrimSpace(account) || item.challenge.Email != strings.TrimSpace(strings.ToLower(email)) || item.challenge.ResourceID != resourceID {
return ErrInvalidChallenge
}
if item.hasBrowserContextDigest {
providedDigest := sha256.Sum256([]byte(strings.TrimSpace(browserContext)))
if strings.TrimSpace(browserContext) == "" || subtle.ConstantTimeCompare(providedDigest[:], item.browserContextDigest[:]) != 1 {
return ErrInvalidChallenge
}
}
if !now.Before(item.challenge.ExpiresAt) {
s.deleteLocked(id)
return ErrExpiredChallenge
}
item.challenge.Attempts++
if item.challenge.Attempts > item.challenge.MaxAttempts {
s.deleteLocked(id)
return ErrTooManyAttempts
}
mac := hmac.New(sha256.New, s.key[:])
_, _ = mac.Write([]byte(item.challenge.ID))
_, _ = mac.Write([]byte{0})
_, _ = mac.Write([]byte(item.challenge.Purpose))
_, _ = mac.Write([]byte{0})
_, _ = mac.Write([]byte(item.challenge.Account))
_, _ = mac.Write([]byte{0})
_, _ = mac.Write([]byte(item.challenge.Email))
_, _ = mac.Write([]byte{0})
_, _ = mac.Write([]byte(fmt.Sprintf("%d", item.challenge.ResourceID)))
_, _ = mac.Write([]byte{0})
_, _ = mac.Write(item.browserContextDigest[:])
_, _ = mac.Write([]byte{0})
_, _ = mac.Write([]byte(code))
actual := mac.Sum(nil)
if subtle.ConstantTimeCompare(actual, item.mac[:]) != 1 {
if item.challenge.Attempts >= item.challenge.MaxAttempts {
s.deleteLocked(id)
return ErrTooManyAttempts
}
s.entries[id] = item
return ErrInvalidChallenge
}
s.deleteLocked(id)
return nil
}
func (s *Store) Cleanup() int {
if s == nil {
return 0
}
s.mu.Lock()
defer s.mu.Unlock()
before := len(s.entries)
s.cleanupLocked(s.now())
return before - len(s.entries)
}
func (s *Store) ResetForProcessRestart() {
if s == nil {
return
}
s.mu.Lock()
defer s.mu.Unlock()
_, _ = rand.Read(s.key[:])
s.entries = make(map[string]entry)
s.active = make(map[string]string)
s.perUser = make(map[string]int)
}
// InvalidateAccount 删除指定账号尚未完成的全部验证码挑战。
func (s *Store) InvalidateAccount(account string) int {
if s == nil {
return 0
}
account = strings.TrimSpace(account)
if account == "" {
return 0
}
s.mu.Lock()
defer s.mu.Unlock()
removed := 0
for id, item := range s.entries {
if item.challenge.Account == account {
s.deleteLocked(id)
removed++
}
}
return removed
}
// InvalidateResource 删除绑定到指定业务资源的全部未完成挑战。
func (s *Store) InvalidateResource(resourceID int, purpose Purpose) int {
if s == nil || resourceID <= 0 {
return 0
}
s.mu.Lock()
defer s.mu.Unlock()
removed := 0
for id, item := range s.entries {
if item.challenge.ResourceID == resourceID && (purpose == "" || item.challenge.Purpose == purpose) {
s.deleteLocked(id)
removed++
}
}
return removed
}
// InvalidateChallenge 删除指定的未完成挑战。
func (s *Store) InvalidateChallenge(id string) bool {
if s == nil || strings.TrimSpace(id) == "" {
return false
}
s.mu.Lock()
defer s.mu.Unlock()
if _, ok := s.entries[id]; !ok {
return false
}
s.deleteLocked(id)
return true
}
func (s *Store) Size() int {
if s == nil {
return 0
}
s.mu.Lock()
defer s.mu.Unlock()
return len(s.entries)
}
func (s *Store) cleanupLocked(now time.Time) {
for id, item := range s.entries {
if !now.Before(item.challenge.ExpiresAt) {
s.deleteLocked(id)
}
}
}
func randomCode(length int) (string, error) {
if length <= 0 || length > 12 {
return "", ErrInvalidChallenge
}
const digits = "0123456789"
code := make([]byte, length)
random := make([]byte, length*2)
for written := 0; written < length; {
if _, err := io.ReadFull(rand.Reader, random); err != nil {
clearBytes(random)
clearBytes(code)
return "", err
}
for _, value := range random {
if value >= 250 {
continue
}
code[written] = digits[int(value)%len(digits)]
written++
if written == length {
break
}
}
}
clearBytes(random)
result := string(code)
clearBytes(code)
return result, nil
}
func randomID() (string, error) {
var raw [16]byte
if _, err := io.ReadFull(rand.Reader, raw[:]); err != nil {
return "", err
}
return hex.EncodeToString(raw[:]), nil
}
func challengeKey(account string, purpose Purpose) string {
return account + "\x00" + string(purpose)
}
func (s *Store) deleteLocked(id string) {
item, ok := s.entries[id]
if !ok {
return
}
delete(s.entries, id)
key := challengeKey(item.challenge.Account, item.challenge.Purpose)
if s.active[key] == id {
delete(s.active, key)
}
if count := s.perUser[item.challenge.Account]; count <= 1 {
delete(s.perUser, item.challenge.Account)
} else {
s.perUser[item.challenge.Account] = count - 1
}
for index := range item.mac {
item.mac[index] = 0
}
}
func clearString(value *string) {
if value == nil {
return
}
buffer := []byte(*value)
clearBytes(buffer)
*value = ""
}
+181
View File
@@ -0,0 +1,181 @@
package verification
import (
"errors"
"testing"
"time"
)
func TestStoreIssuesAndConsumesCodeOnlyOnce(t *testing.T) {
store, err := NewStore(4)
if err != nil {
t.Fatal(err)
}
var issuedCode string
challenge, err := store.Issue(IssueRequest{Purpose: PurposeLogin, Account: "smail", Email: "User@Example.com"}, func(challenge Challenge, code string) error {
issuedCode = code
return nil
})
if err != nil {
t.Fatal(err)
}
if issuedCode == "" || store.Size() != 1 {
t.Fatal("challenge was not retained in memory")
}
if err := store.Verify(challenge.ID, "smail", "user@example.com", issuedCode, PurposeLogin); err != nil {
t.Fatal(err)
}
if store.Size() != 0 {
t.Fatal("verified challenge was not consumed")
}
if err := store.Verify(challenge.ID, "smail", "user@example.com", issuedCode, PurposeLogin); !errors.Is(err, ErrInvalidChallenge) {
t.Fatalf("replayed challenge was accepted: %v", err)
}
}
func TestStoreLimitsAttemptsAndExpires(t *testing.T) {
store, err := NewStore(4)
if err != nil {
t.Fatal(err)
}
var code string
challenge, err := store.Issue(IssueRequest{Purpose: PurposePasswordRecover, Account: "smail", Email: "user@example.com", TTL: time.Second, MaxAttempts: 2}, func(_ Challenge, issued string) error {
code = issued
return nil
})
if err != nil {
t.Fatal(err)
}
wrongCode := "000000"
if code == wrongCode {
wrongCode = "111111"
}
if err := store.Verify(challenge.ID, "smail", "user@example.com", wrongCode, PurposePasswordRecover); err == nil {
t.Fatal("wrong code was accepted")
}
if err := store.Verify(challenge.ID, "smail", "user@example.com", wrongCode, PurposePasswordRecover); !errors.Is(err, ErrTooManyAttempts) {
t.Fatalf("wrong code result = %v", err)
}
if err := store.Verify(challenge.ID, "smail", "user@example.com", code, PurposePasswordRecover); !errors.Is(err, ErrInvalidChallenge) {
t.Fatalf("replayed exhausted challenge result = %v", err)
}
challenge, err = store.Issue(IssueRequest{Purpose: PurposeLogin, Account: "smail", Email: "user@example.com", TTL: time.Nanosecond}, func(_ Challenge, _ string) error { return nil })
if err != nil {
t.Fatal(err)
}
time.Sleep(time.Millisecond)
if err := store.Verify(challenge.ID, "smail", "user@example.com", code, PurposeLogin); !errors.Is(err, ErrInvalidChallenge) && !errors.Is(err, ErrExpiredChallenge) {
t.Fatalf("expired challenge result = %v", err)
}
}
func TestStoreRestartInvalidatesAllChallenges(t *testing.T) {
store, err := NewStore(4)
if err != nil {
t.Fatal(err)
}
challenge, err := store.Issue(IssueRequest{Purpose: PurposeLogin, Account: "smail", Email: "user@example.com"}, func(_ Challenge, _ string) error { return nil })
if err != nil {
t.Fatal(err)
}
store.ResetForProcessRestart()
if store.Size() != 0 {
t.Fatal("restart did not clear in-memory challenges")
}
if err := store.Verify(challenge.ID, "smail", "user@example.com", "000000", PurposeLogin); err == nil {
t.Fatal("challenge survived process restart")
}
}
func TestInvalidateAccountOnlyRemovesTargetChallenges(t *testing.T) {
store, err := NewStore(4)
if err != nil {
t.Fatal(err)
}
codes := make(map[string]string)
delivery := func(challenge Challenge, code string) error {
codes[challenge.Account] = code
return nil
}
target, err := store.Issue(IssueRequest{Purpose: PurposeLogin, Account: "root", Email: "root@example.com"}, delivery)
if err != nil {
t.Fatal(err)
}
other, err := store.Issue(IssueRequest{Purpose: PurposeLogin, Account: "alice", Email: "alice@example.com"}, delivery)
if err != nil {
t.Fatal(err)
}
if removed := store.InvalidateAccount("root"); removed != 1 {
t.Fatalf("removed challenges = %d", removed)
}
if err := store.Verify(target.ID, "root", "root@example.com", codes["root"], PurposeLogin); !errors.Is(err, ErrInvalidChallenge) {
t.Fatalf("target challenge survived invalidation: %v", err)
}
if err := store.Verify(other.ID, "alice", "alice@example.com", codes["alice"], PurposeLogin); err != nil {
t.Fatalf("other challenge was invalidated: %v", err)
}
}
func TestStoreUsesEightDigitCodesAndReissueInvalidatesPrevious(t *testing.T) {
store, err := NewStore(8)
if err != nil {
t.Fatal(err)
}
var firstCode string
first, err := store.Issue(IssueRequest{Purpose: PurposeLogin, Account: "smail", Email: "user@example.com"}, func(_ Challenge, code string) error {
firstCode = code
return nil
})
if err != nil {
t.Fatal(err)
}
if len(firstCode) != DefaultCodeLength {
t.Fatalf("code length = %d, want %d", len(firstCode), DefaultCodeLength)
}
var secondCode string
second, err := store.Issue(IssueRequest{Purpose: PurposeLogin, Account: "smail", Email: "user@example.com"}, func(_ Challenge, code string) error {
secondCode = code
return nil
})
if err != nil {
t.Fatal(err)
}
if first.ID == second.ID || store.Size() != 1 {
t.Fatal("reissue did not replace the previous challenge")
}
if err := store.Verify(first.ID, "smail", "user@example.com", firstCode, PurposeLogin); !errors.Is(err, ErrInvalidChallenge) {
t.Fatalf("old challenge result = %v", err)
}
if err := store.Verify(second.ID, "smail", "user@example.com", secondCode, PurposeLogin); err != nil {
t.Fatal(err)
}
}
func TestStoreRejectsDifferentBrowserContextWithoutConsumingChallenge(t *testing.T) {
store, err := NewStore(4)
if err != nil {
t.Fatal(err)
}
var code string
challenge, err := store.Issue(IssueRequest{
Purpose: PurposePasswordRecover,
Account: "smail",
Email: "user@example.com",
BrowserTransaction: "browser-a",
}, func(_ Challenge, issued string) error {
code = issued
return nil
})
if err != nil {
t.Fatal(err)
}
if err := store.VerifyBoundWithContext(challenge.ID, "smail", "user@example.com", code, PurposePasswordRecover, 0, "browser-b"); !errors.Is(err, ErrInvalidChallenge) {
t.Fatalf("different browser context result = %v", err)
}
if store.Size() != 1 {
t.Fatal("context mismatch consumed the challenge")
}
if err := store.VerifyBoundWithContext(challenge.ID, "smail", "user@example.com", code, PurposePasswordRecover, 0, "browser-a"); err != nil {
t.Fatalf("matching browser context result = %v", err)
}
}