统一 frontend、backend、test、test-log 和 out 目录,更新构建、部署及测试入口;纳入配置管理兼容与首次安全引导修复;排除本机配置、密钥和测试产物。
This commit is contained in:
1 parent
28cd9d3406
commit
f60d3b0880
603 files changed
+2351
-660
No files matched your search
@@ -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()
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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 = ""
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user