feat: add password recovery flow (#358)

This commit is contained in:
MasterChiefCN authored and GitHub committed 2026-08-31 09:58:36 +08:00
1 parent 8ebceecbb6
commit e124a9ea04
19 files changed
+875 -52

No files matched your search

+48
View File
@@ -2,6 +2,7 @@ package handler
import (
"bytes"
"crypto/sha256"
"encoding/json"
"errors"
"fmt"
@@ -66,6 +67,48 @@ func RegisterAuthRoutes(r *gin.RouterGroup, svc *service.Service) {
}
ok(c, gin.H{"sent": true})
})
r.POST("/auth/password-reset-code", func(c *gin.Context) {
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 16<<10)
var req struct {
Email string `json:"email"`
}
if err := c.ShouldBindJSON(&req); err != nil {
fail(c, http.StatusBadRequest, err)
return
}
policy, available := loadRuntimePolicy(c, svc)
if !available || !enforceRateLimit(c, "password-reset-code-ip:"+c.ClientIP(), policy.Request.EmailCodePerHour, time.Hour) {
return
}
if !enforceRateLimit(c, "password-reset-code-account:"+passwordResetRateLimitSubject(req.Email), policy.Request.EmailCodePerHour, time.Hour) {
return
}
if err := svc.SendPasswordResetEmailCode(req.Email); err != nil {
failService(c, err)
return
}
ok(c, gin.H{"sent": true})
})
r.POST("/auth/password-reset", func(c *gin.Context) {
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 64<<10)
var req service.PasswordResetRequest
if err := c.ShouldBindJSON(&req); err != nil {
fail(c, http.StatusBadRequest, err)
return
}
policy, available := loadRuntimePolicy(c, svc)
if !available || !enforceRateLimit(c, "password-reset-ip:"+c.ClientIP(), policy.Request.LoginIPPerTenMinutes, 10*time.Minute) {
return
}
if !enforceRateLimit(c, "password-reset-account:"+passwordResetRateLimitSubject(req.Email), policy.Request.LoginAccountPerTenMinutes, 10*time.Minute) {
return
}
if err := svc.ResetPassword(req); err != nil {
failService(c, err)
return
}
ok(c, gin.H{"reset": true})
})
r.POST("/auth/login", func(c *gin.Context) {
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 64<<10)
var req service.LoginRequest
@@ -1069,6 +1112,11 @@ func sessionCookie(c *gin.Context) string {
return value
}
func passwordResetRateLimitSubject(value string) string {
sum := sha256.Sum256([]byte(strings.ToLower(strings.TrimSpace(value))))
return fmt.Sprintf("%x", sum[:])
}
func setSessionCookie(c *gin.Context, value string, maxAge int) {
secure := c.Request.TLS != nil || strings.EqualFold(strings.TrimSpace(c.GetHeader("X-Forwarded-Proto")), "https")
http.SetCookie(c.Writer, &http.Cookie{
+11
View File
@@ -10,6 +10,17 @@ import (
"infinite-canvas/backend/internal/model"
)
func TestPasswordResetRateLimitSubjectNormalizesAndHashesEmail(t *testing.T) {
first := passwordResetRateLimitSubject(" Creator@Example.com ")
second := passwordResetRateLimitSubject("creator@example.com")
if first != second {
t.Fatalf("normalized subjects differ: %q != %q", first, second)
}
if first == "creator@example.com" || strings.Contains(first, "@") || len(first) != 64 {
t.Fatalf("rate limit subject is not a SHA-256 digest: %q", first)
}
}
func TestAuthorizeSystemProxyAllowsConfiguredGenerationModel(t *testing.T) {
channel := &model.ModelChannel{APIFormat: "openai", ModelsJSON: `["gpt-image-1"]`}
body := []byte(`{"model":"gpt-image-1","prompt":"test"}`)
+32
View File
@@ -26,6 +26,8 @@ var ErrTextReplayQuotaExceeded = errors.New("text replay quota exceeded")
var ErrTextReplayClosed = errors.New("text replay task is closed")
var ErrEmailVerificationCodeInvalid = errors.New("email verification code is no longer valid")
var ErrProjectAssetFolderNotEmpty = errors.New("project asset folder is not empty")
var ErrProjectHasActiveTasks = errors.New("project has active tasks")
@@ -307,6 +309,36 @@ func (r *Repository) CreateUserWithEmailVerification(user *model.User, verificat
})
}
func (r *Repository) ResetUserPasswordWithEmailVerification(userID string, email string, purpose string, verificationCodeID string, passwordHash string, usedAt time.Time) error {
return r.db.Transaction(func(tx *gorm.DB) error {
codeResult := tx.Model(&model.EmailVerificationCode{}).
Where("id = ? AND email = ? AND purpose = ? AND used_at IS NULL AND expires_at > ?", verificationCodeID, email, purpose, usedAt).
Update("used_at", usedAt)
if codeResult.Error != nil {
return codeResult.Error
}
if codeResult.RowsAffected != 1 {
return ErrEmailVerificationCodeInvalid
}
userResult := tx.Model(&model.User{}).
Where("id = ? AND email <> '' AND lower(email) = lower(?) AND status = ? AND password_hash <> ''", userID, email, model.UserStatusActive).
Updates(map[string]any{"password_hash": passwordHash, "updated_at": usedAt})
if userResult.Error != nil {
return userResult.Error
}
if userResult.RowsAffected != 1 {
return ErrEmailVerificationCodeInvalid
}
if err := tx.Delete(&model.AuthSession{}, "user_id = ?", userID).Error; err != nil {
return err
}
return tx.Model(&model.EmailVerificationCode{}).
Where("email = ? AND purpose = ? AND used_at IS NULL", email, purpose).
Update("used_at", usedAt).Error
})
}
func (r *Repository) DeleteExpiredEmailVerificationCodes(now time.Time) error {
return r.db.Delete(&model.EmailVerificationCode{}, "expires_at <= ? OR used_at IS NOT NULL", now).Error
}
+12 -5
View File
@@ -159,7 +159,7 @@ func (s *Service) SendRegistrationEmailCode(rawEmail string) error {
if err != nil {
return err
}
codeHash, err := s.emailVerificationCodeHash(email, code)
codeHash, err := s.emailVerificationCodeHash(registrationEmailPurpose, email, code)
if err != nil {
return err
}
@@ -168,7 +168,7 @@ func (s *Service) SendRegistrationEmailCode(rawEmail string) error {
if err := s.repo.Create(&record); err != nil {
return err
}
if err := sendSMTPMail(setting, email, "影策注册验证码", registrationEmailBody(code)); err != nil {
if err := s.deliverEmail(setting, email, "影策注册验证码", registrationEmailBody(code)); err != nil {
cleanupErr := s.repo.DeleteEmailVerificationCode(record.ID)
if cleanupErr != nil {
return errors.Join(
@@ -206,7 +206,7 @@ func (s *Service) VerifyRegistrationEmailCode(email string, rawCode string) (*mo
if time.Now().After(record.ExpiresAt) {
return nil, BadAuthRequest("邮箱验证码已过期,请重新获取")
}
hash, err := s.emailVerificationCodeHash(email, code)
hash, err := s.emailVerificationCodeHash(registrationEmailPurpose, email, code)
if err != nil {
return nil, err
}
@@ -216,13 +216,13 @@ func (s *Service) VerifyRegistrationEmailCode(email string, rawCode string) (*mo
return record, nil
}
func (s *Service) emailVerificationCodeHash(email string, code string) (string, error) {
func (s *Service) emailVerificationCodeHash(purpose string, email string, code string) (string, error) {
key, err := s.settingsEncryptionKey()
if err != nil {
return "", err
}
mac := hmac.New(sha256.New, key)
_, _ = mac.Write([]byte(registrationEmailPurpose + ":" + email + ":" + code))
_, _ = mac.Write([]byte(strings.TrimSpace(purpose) + ":" + normalizeEmail(email) + ":" + strings.TrimSpace(code)))
return hex.EncodeToString(mac.Sum(nil)), nil
}
@@ -347,6 +347,13 @@ func sendSMTPMail(setting emailSettingValue, recipient string, subject string, b
return client.Quit()
}
func (s *Service) deliverEmail(setting emailSettingValue, recipient string, subject string, body string) error {
if s.mailSender != nil {
return s.mailSender(setting, recipient, subject, body)
}
return sendSMTPMail(setting, recipient, subject, body)
}
func randomNumericCode(length int) (string, error) {
limit := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(length)), nil)
value, err := rand.Int(rand.Reader, limit)
+157
View File
@@ -0,0 +1,157 @@
package service
import (
"crypto/hmac"
"errors"
"log"
"strings"
"time"
"infinite-canvas/backend/internal/model"
"infinite-canvas/backend/internal/repository"
"gorm.io/gorm"
)
const passwordResetEmailPurpose = "password_reset"
const passwordResetCodeTTL = 10 * time.Minute
type PasswordResetRequest struct {
Email string `json:"email"`
EmailCode string `json:"emailCode"`
Password string `json:"password"`
}
func (s *Service) SendPasswordResetEmailCode(rawEmail string) error {
email := normalizeEmail(rawEmail)
if err := validateEmail(email); err != nil {
return err
}
_, setting, err := s.readEmailSetting()
if err != nil {
return err
}
if !setting.Enabled || setting.Host == "" || setting.Port < 1 || setting.FromEmail == "" {
return Forbidden("管理员尚未启用密码找回,请联系管理员")
}
s.emailCodeMu.Lock()
defer s.emailCodeMu.Unlock()
user, err := s.repo.UserByEmail(email)
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil
}
if err != nil {
return err
}
if user.Status != model.UserStatusActive || strings.TrimSpace(user.PasswordHash) == "" {
return nil
}
if latest, latestErr := s.repo.LatestEmailVerificationCode(email, passwordResetEmailPurpose); latestErr == nil && time.Since(latest.CreatedAt) < time.Minute {
return nil
} else if latestErr != nil && !errors.Is(latestErr, gorm.ErrRecordNotFound) {
return latestErr
}
code, err := randomNumericCode(6)
if err != nil {
return err
}
codeHash, err := s.emailVerificationCodeHash(passwordResetEmailPurpose, email, code)
if err != nil {
return err
}
now := time.Now()
record := model.EmailVerificationCode{
ID: newID(),
Email: email,
CodeHash: codeHash,
Purpose: passwordResetEmailPurpose,
ExpiresAt: now.Add(passwordResetCodeTTL),
CreatedAt: now,
}
if err := s.repo.Create(&record); err != nil {
return err
}
if err := s.deliverEmail(setting, email, "影策密码重置验证码", passwordResetEmailBody(code)); err != nil {
if cleanupErr := s.repo.DeleteEmailVerificationCode(record.ID); cleanupErr != nil {
log.Printf("password reset email cleanup failed: recipient=%s error=%v", maskedEmail(email), cleanupErr)
}
log.Printf("password reset email delivery failed: recipient=%s error=%v", maskedEmail(email), err)
return nil
}
if cleanupErr := s.repo.DeleteExpiredEmailVerificationCodes(now.Add(-24 * time.Hour)); cleanupErr != nil {
log.Printf("expired password reset code cleanup failed: error=%v", cleanupErr)
}
return nil
}
func (s *Service) ResetPassword(req PasswordResetRequest) error {
email := normalizeEmail(req.Email)
if err := validateEmail(email); err != nil {
return err
}
if err := validatePassword(req.Password); err != nil {
return err
}
code := strings.TrimSpace(req.EmailCode)
if len(code) != 6 {
return invalidPasswordResetCode()
}
user, err := s.repo.UserByEmail(email)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return invalidPasswordResetCode()
}
return err
}
if user.Status != model.UserStatusActive || strings.TrimSpace(user.PasswordHash) == "" {
return invalidPasswordResetCode()
}
record, err := s.repo.LatestEmailVerificationCode(email, passwordResetEmailPurpose)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return invalidPasswordResetCode()
}
return err
}
if time.Now().After(record.ExpiresAt) {
return invalidPasswordResetCode()
}
expectedHash, err := s.emailVerificationCodeHash(passwordResetEmailPurpose, email, code)
if err != nil {
return err
}
if !hmac.Equal([]byte(expectedHash), []byte(record.CodeHash)) {
return invalidPasswordResetCode()
}
passwordHash, err := hashPassword(req.Password)
if err != nil {
return err
}
if err := s.repo.ResetUserPasswordWithEmailVerification(user.ID, email, passwordResetEmailPurpose, record.ID, passwordHash, time.Now()); err != nil {
if errors.Is(err, repository.ErrEmailVerificationCodeInvalid) {
return invalidPasswordResetCode()
}
return err
}
return nil
}
func invalidPasswordResetCode() *AuthError {
return BadAuthRequest("验证码无效或已过期")
}
func passwordResetEmailBody(code string) string {
return "你正在重置影策账号密码。\n\n验证码:" + code + "\n\n验证码 10 分钟内有效。若非本人操作,请忽略本邮件,并确保邮箱账号安全。"
}
func maskedEmail(email string) string {
parts := strings.SplitN(email, "@", 2)
if len(parts) != 2 || parts[0] == "" {
return "***"
}
return string([]rune(parts[0])[0]) + "***@" + parts[1]
}
@@ -0,0 +1,225 @@
package service
import (
"encoding/json"
"errors"
"strings"
"testing"
"time"
"infinite-canvas/backend/internal/model"
"infinite-canvas/backend/internal/repository"
"golang.org/x/crypto/bcrypt"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
)
func TestPasswordResetChangesPasswordConsumesCodeAndRevokesSessions(t *testing.T) {
svc, db := newPasswordResetTestService(t)
oldHash, err := hashPassword("old-password")
if err != nil {
t.Fatal(err)
}
user := model.User{ID: "user-1", Username: "creator", Email: "creator@example.com", DisplayName: "Creator", Role: model.UserRoleUser, Status: model.UserStatusActive, PasswordHash: oldHash}
if err := db.Create(&user).Error; err != nil {
t.Fatal(err)
}
sessions := []model.AuthSession{
{ID: "session-1", UserID: user.ID, TokenHash: "one", ExpiresAt: time.Now().Add(time.Hour)},
{ID: "session-2", UserID: user.ID, TokenHash: "two", ExpiresAt: time.Now().Add(time.Hour)},
}
if err := db.Create(&sessions).Error; err != nil {
t.Fatal(err)
}
var deliveredCode string
svc.mailSender = func(_ emailSettingValue, recipient string, subject string, body string) error {
if recipient != user.Email || subject != "影策密码重置验证码" {
t.Fatalf("unexpected reset email: recipient=%q subject=%q", recipient, subject)
}
deliveredCode = codeFromEmailBody(body)
return nil
}
if err := svc.SendPasswordResetEmailCode(" Creator@Example.com "); err != nil {
t.Fatal(err)
}
if err := svc.SendPasswordResetEmailCode(user.Email); err != nil {
t.Fatalf("repeat send should keep the public response generic: %v", err)
}
if len(deliveredCode) != 6 {
t.Fatalf("delivered code = %q", deliveredCode)
}
var storedCode model.EmailVerificationCode
if err := db.Where("email = ? AND purpose = ?", user.Email, passwordResetEmailPurpose).First(&storedCode).Error; err != nil {
t.Fatal(err)
}
if storedCode.CodeHash == deliveredCode || storedCode.CodeHash == "" {
t.Fatalf("verification code was not hashed: %#v", storedCode)
}
if err := svc.ResetPassword(PasswordResetRequest{Email: user.Email, EmailCode: deliveredCode, Password: "new-password"}); err != nil {
t.Fatal(err)
}
var updated model.User
if err := db.First(&updated, "id = ?", user.ID).Error; err != nil {
t.Fatal(err)
}
if bcrypt.CompareHashAndPassword([]byte(updated.PasswordHash), []byte("new-password")) != nil {
t.Fatal("new password hash does not match")
}
if bcrypt.CompareHashAndPassword([]byte(updated.PasswordHash), []byte("old-password")) == nil {
t.Fatal("old password still matches")
}
var sessionCount int64
if err := db.Model(&model.AuthSession{}).Where("user_id = ?", user.ID).Count(&sessionCount).Error; err != nil {
t.Fatal(err)
}
if sessionCount != 0 {
t.Fatalf("auth session count = %d, want 0", sessionCount)
}
if err := db.First(&storedCode, "id = ?", storedCode.ID).Error; err != nil {
t.Fatal(err)
}
if storedCode.UsedAt == nil {
t.Fatal("password reset code was not consumed")
}
if err := svc.ResetPassword(PasswordResetRequest{Email: user.Email, EmailCode: deliveredCode, Password: "another-password"}); !isInvalidPasswordResetError(err) {
t.Fatalf("reused code error = %v", err)
}
}
func TestPasswordResetSendDoesNotRevealAccountEligibility(t *testing.T) {
svc, db := newPasswordResetTestService(t)
hash, err := hashPassword("strong-password")
if err != nil {
t.Fatal(err)
}
users := []model.User{
{ID: "oauth-user", Username: "oauth-user", Email: "oauth@example.com", Status: model.UserStatusActive},
{ID: "disabled-user", Username: "disabled-user", Email: "disabled@example.com", Status: model.UserStatusDisabled, PasswordHash: hash},
}
if err := db.Create(&users).Error; err != nil {
t.Fatal(err)
}
deliveries := 0
svc.mailSender = func(_ emailSettingValue, _ string, _ string, _ string) error {
deliveries++
return nil
}
for _, email := range []string{"missing@example.com", "oauth@example.com", "disabled@example.com"} {
if err := svc.SendPasswordResetEmailCode(email); err != nil {
t.Fatalf("SendPasswordResetEmailCode(%q) error = %v", email, err)
}
}
if deliveries != 0 {
t.Fatalf("mail deliveries = %d, want 0", deliveries)
}
var codeCount int64
if err := db.Model(&model.EmailVerificationCode{}).Count(&codeCount).Error; err != nil {
t.Fatal(err)
}
if codeCount != 0 {
t.Fatalf("verification code count = %d, want 0", codeCount)
}
}
func TestPasswordResetRejectsWrongExpiredAndPurposeMismatchedCodes(t *testing.T) {
svc, db := newPasswordResetTestService(t)
hash, err := hashPassword("old-password")
if err != nil {
t.Fatal(err)
}
user := model.User{ID: "user-1", Username: "creator", Email: "creator@example.com", Status: model.UserStatusActive, PasswordHash: hash}
if err := db.Create(&user).Error; err != nil {
t.Fatal(err)
}
resetHash, err := svc.emailVerificationCodeHash(passwordResetEmailPurpose, user.Email, "123456")
if err != nil {
t.Fatal(err)
}
registrationHash, err := svc.emailVerificationCodeHash(registrationEmailPurpose, user.Email, "123456")
if err != nil {
t.Fatal(err)
}
if resetHash == registrationHash {
t.Fatal("email verification hashes must be separated by purpose")
}
record := model.EmailVerificationCode{ID: "expired", Email: user.Email, Purpose: passwordResetEmailPurpose, CodeHash: resetHash, ExpiresAt: time.Now().Add(-time.Minute), CreatedAt: time.Now().Add(-11 * time.Minute)}
if err := db.Create(&record).Error; err != nil {
t.Fatal(err)
}
if err := svc.ResetPassword(PasswordResetRequest{Email: user.Email, EmailCode: "123456", Password: "new-password"}); !isInvalidPasswordResetError(err) {
t.Fatalf("expired code error = %v", err)
}
record.ID = "active"
record.ExpiresAt = time.Now().Add(time.Minute)
record.CreatedAt = time.Now()
if err := db.Create(&record).Error; err != nil {
t.Fatal(err)
}
if err := svc.ResetPassword(PasswordResetRequest{Email: user.Email, EmailCode: "654321", Password: "new-password"}); !isInvalidPasswordResetError(err) {
t.Fatalf("wrong code error = %v", err)
}
}
func TestPasswordResetDeliveryFailureRemovesUnusableCode(t *testing.T) {
svc, db := newPasswordResetTestService(t)
hash, err := hashPassword("old-password")
if err != nil {
t.Fatal(err)
}
user := model.User{ID: "user-1", Username: "creator", Email: "creator@example.com", Status: model.UserStatusActive, PasswordHash: hash}
if err := db.Create(&user).Error; err != nil {
t.Fatal(err)
}
svc.mailSender = func(_ emailSettingValue, _ string, _ string, _ string) error { return errors.New("smtp unavailable") }
if err := svc.SendPasswordResetEmailCode(user.Email); err != nil {
t.Fatalf("delivery failure should keep the public response generic: %v", err)
}
var count int64
if err := db.Model(&model.EmailVerificationCode{}).Count(&count).Error; err != nil {
t.Fatal(err)
}
if count != 0 {
t.Fatalf("verification code count = %d, want 0", count)
}
}
func newPasswordResetTestService(t *testing.T) (*Service, *gorm.DB) {
t.Helper()
db, err := gorm.Open(sqlite.Open("file:"+newID()+"?mode=memory&cache=shared"), &gorm.Config{})
if err != nil {
t.Fatal(err)
}
if err := db.AutoMigrate(&model.User{}, &model.AuthSession{}, &model.EmailVerificationCode{}, &model.SystemSetting{}); err != nil {
t.Fatal(err)
}
settingJSON, err := json.Marshal(emailSettingValue{Enabled: true, Host: "smtp.example.com", Port: 587, Encryption: "starttls", FromEmail: "noreply@example.com", FromName: "影策"})
if err != nil {
t.Fatal(err)
}
if err := db.Create(&model.SystemSetting{Key: emailSettingKey, ValueJSON: string(settingJSON)}).Error; err != nil {
t.Fatal(err)
}
return &Service{repo: repository.New(db), dataDir: t.TempDir()}, db
}
func codeFromEmailBody(body string) string {
marker := "验证码:"
start := strings.Index(body, marker)
if start < 0 {
return ""
}
value := body[start+len(marker):]
if end := strings.IndexByte(value, '\n'); end >= 0 {
value = value[:end]
}
return strings.TrimSpace(value)
}
func isInvalidPasswordResetError(err error) bool {
var appErr *AppError
return errors.As(err, &appErr) && appErr.Status == 400 && appErr.Message == "验证码无效或已过期"
}
+1
View File
@@ -53,6 +53,7 @@ type Service struct {
routeHealthBlocked map[string]time.Time
workers *workerRuntime
updateManager UpdateManager
mailSender func(emailSettingValue, string, string, string) error
}
const taskWorkerConcurrency = 3