完善登录页分角色密码重置流程并保留安全中心入口
Security Checks / security (push) Waiting to run

This commit is contained in:
xuans committed 2026-09-18 18:20:53 +08:00
1 parent 1aac3fc2ec
commit e408287dd4
14 files changed
+952 -50

No files matched your search

@@ -0,0 +1,85 @@
package controllers
import (
"encoding/json"
"errors"
"net/http"
"strings"
"git.pcux.cn/xuans/Smail/services/recovery"
"git.pcux.cn/xuans/Smail/services/verification"
"git.pcux.cn/xuans/Smail/utils/password"
)
// 新恢复入口不依赖登录 Cookie,每一步由短期一次性令牌关联。
func PublicPasswordRecoveryFlow(w http.ResponseWriter, req *http.Request) {
fail := func(status int, message string) {
writePublicRecoveryJSON(w, status, map[string]string{"message": message})
}
if !PublicMailRecoveryEnabled() || req == nil || req.Method != http.MethodPost {
fail(http.StatusBadRequest, "密码重置功能未启用")
return
}
limiter := emailRecoveryBeginIPAttempts
key := limiter.ipKey(req)
if limiter.blocked(key) || emailRecoveryFailureIPAttempts.blocked(emailRecoveryFailureIPAttempts.ipKey(req)) {
fail(http.StatusTooManyRequests, "请求过于频繁,请稍后重试")
return
}
limiter.recordFailure(key)
var input struct {
Identifier string `json:"identifier"`
Token string `json:"token"`
Method string `json:"method"`
Code string `json:"code"`
NewPassword string `json:"new_password"`
}
decoder := json.NewDecoder(req.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(&input); err != nil {
fail(http.StatusBadRequest, "请求格式无效")
return
}
service := currentSecurityRuntime().recovery
if service == nil {
fail(http.StatusServiceUnavailable, "重置服务暂时不可用")
return
}
var result any
var err error
switch strings.TrimSuffix(req.URL.Path, "/") {
case "/rest/api/recovery/begin":
result, err = service.IdentifyPublicFlow(input.Identifier)
case "/rest/api/recovery/send-code":
err = service.SendPublicFlowCode(input.Token, remoteIP(req))
result = map[string]any{"sent": true, "retry_after": 60}
case "/rest/api/recovery/verify":
var token string
token, err = service.VerifyPublicFlow(input.Token, input.Method, input.Code, remoteIP(req))
result = map[string]string{"token": token}
case "/rest/api/recovery/reset":
err = service.CompletePublicFlow(input.Token, input.NewPassword)
result = map[string]bool{"reset": true}
default:
http.NotFound(w, req)
return
}
if err != nil {
if errors.Is(err, password.ErrBusy) || errors.Is(err, recovery.ErrUnavailable) {
fail(http.StatusServiceUnavailable, "重置服务暂时不可用,请稍后重试")
} else if errors.Is(err, verification.ErrRateLimited) {
fail(http.StatusTooManyRequests, "验证码发送过于频繁,请稍后重试")
} else if strings.HasSuffix(req.URL.Path, "/send-code") {
fail(http.StatusBadRequest, "验证码未发送,请检查邮箱绑定或稍后重试")
} else if strings.HasSuffix(req.URL.Path, "/begin") {
fail(http.StatusBadRequest, "账号不存在、已停用或无法使用此通道")
} else if errors.Is(err, recovery.ErrInvalidNewPassword) {
fail(http.StatusBadRequest, "新密码长度必须为 8-12 字节")
} else {
emailRecoveryFailureIPAttempts.recordFailure(emailRecoveryFailureIPAttempts.ipKey(req))
fail(http.StatusBadRequest, "验证未通过或流程已失效,请核对信息或重新开始")
}
return
}
writePublicRecoveryJSON(w, http.StatusOK, result)
}
@@ -0,0 +1,58 @@
package controllers
import (
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
)
func TestPublicRecoveryFlowHTTP(t *testing.T) {
enablePublicRecoveryForTest(t)
s, _, _, user, super := newPublicSecurityFixture(t)
previous := currentSecurityRuntime()
ConfigureSecurityRuntime(nil, nil, s, nil)
oldBegin, oldFailure := emailRecoveryBeginIPAttempts, emailRecoveryFailureIPAttempts
emailRecoveryBeginIPAttempts, emailRecoveryFailureIPAttempts = newLoginLimiter(100), newLoginLimiter(100)
t.Cleanup(func() {
ConfigureSecurityRuntime(previous.verification, previous.external, previous.recovery, previous.credentials)
emailRecoveryBeginIPAttempts, emailRecoveryFailureIPAttempts = oldBegin, oldFailure
})
invoke := func(endpoint, body string) (int, map[string]any) {
t.Helper()
r := httptest.NewRequest(http.MethodPost, "https://example.com/rest/api/recovery/"+endpoint, strings.NewReader(body))
r.RemoteAddr = "192.0.2.70:12345"
w := httptest.NewRecorder()
PublicPasswordRecoveryFlow(w, r)
var data map[string]any
if err := json.Unmarshal(w.Body.Bytes(), &data); err != nil {
t.Fatal(err)
}
if w.Header().Get("Cache-Control") != "no-store" {
t.Fatal("recovery response cached")
}
return w.Code, data
}
status, data := invoke("begin", `{"identifier":"`+super.Account+`"}`)
if status != 200 || data["role"] != "super_admin" || data["token"] != nil {
t.Fatalf("super response: %v", data)
}
status, data = invoke("begin", `{"identifier":"`+user.Account+`"}`)
if status != 200 || data["email"] != "a***@example.com" {
t.Fatalf("identity response: %v", data)
}
token := data["token"].(string)
if status, _ := invoke("reset", `{"token":"`+token+`","new_password":"NewPass123"}`); status == 200 {
t.Fatal("unverified reset accepted")
}
if status, _ := invoke("verify", `{"token":"`+token+`","method":"email","code":"12345678"}`); status == 200 {
t.Fatal("unsent code accepted")
}
if status, _ := invoke("begin", `{"identifier":"missing"}`); status == 200 {
t.Fatal("missing user accepted")
}
if status, _ := invoke("begin", `{"identifier":"alice","role":"super_admin"}`); status == 200 {
t.Fatal("client role accepted")
}
}
@@ -62,11 +62,13 @@ func (h *publicRecoveryHandler) ServeHTTP(w http.ResponseWriter, r *http.Request
case "/rest", "/rest/":
h.servePage(w, r)
case "/rest/api/recovery/begin":
h.serveAPI(w, r, controllers.BeginPublicLinkPasswordRecovery)
h.serveAPI(w, r, controllers.PublicPasswordRecoveryFlow)
case "/rest/api/recovery/send-code", "/rest/api/recovery/verify", "/rest/api/recovery/reset":
h.serveAPI(w, r, controllers.PublicPasswordRecoveryFlow)
case "/rest/api/recovery/requirements":
h.serveAPI(w, r, controllers.PublicLinkPasswordRecoveryRequirements)
case "/rest/api/recovery/complete":
h.serveAPI(w, r, controllers.CompletePublicLinkPasswordRecovery)
http.NotFound(w, r)
default:
if isPublicRecoveryAssetPath(path) {
h.serveStatic(w, r)
+227
View File
@@ -0,0 +1,227 @@
package recovery
import (
"errors"
"strings"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/access"
"git.pcux.cn/xuans/Smail/services/auth"
"git.pcux.cn/xuans/Smail/services/verification"
"git.pcux.cn/xuans/Smail/utils/password"
)
type PublicFlow struct {
Token string `json:"token,omitempty"`
Role access.Role `json:"role"`
Email string `json:"email"`
Methods []string `json:"methods"`
}
// IdentifyPublicFlow 只公开脱敏邮箱,验证方式由数据库角色和已配置凭据决定。
func (s *Service) IdentifyPublicFlow(identifier string) (*PublicFlow, error) {
if s == nil || s.engine == nil || s.external == nil || s.credentials == nil {
return nil, ErrUnavailable
}
account, err := auth.NormalizeIdentifier(identifier)
if err != nil || account == "" {
return nil, ErrRecoveryDenied
}
var user models.User
found, err := s.engine.Where("account = ? AND disabled = 0", account).Get(&user)
if err != nil {
return nil, ErrUnavailable
}
if !found {
return nil, ErrRecoveryDenied
}
result := &PublicFlow{Role: user.EffectiveRole(), Methods: []string{}}
if result.Role == access.RoleSuperAdmin {
return result, nil
}
item := &publicTicket{Flow: true, UserID: user.ID, Account: user.Account, Role: user.EffectiveRole(), SessionVersion: user.SessionVersion, SecurityVersion: user.SecurityVersion}
bindings, err := s.external.List(user.ID)
if err != nil {
return nil, ErrUnavailable
}
var binding *models.ExternalEmail
for i := range bindings {
candidate := &bindings[i]
if candidate.Status != models.ExternalEmailStatusVerified {
continue
}
if candidate.EmailType == models.ExternalEmailTypePrimary {
binding = candidate
break
}
if candidate.EmailType == models.ExternalEmailTypeBackup && binding == nil {
binding = candidate
}
}
if binding != nil {
email, err := s.external.Decrypt(*binding)
if err != nil {
return nil, ErrUnavailable
}
parts := strings.SplitN(email, "@", 2)
if len(parts) != 2 || parts[0] == "" {
return nil, ErrUnavailable
}
result.Email = string([]rune(parts[0])[0]) + "***@" + parts[1]
item.CredentialID, item.CredentialVersion = binding.ID, binding.CredentialVersion
if s.verification != nil {
result.Methods = append(result.Methods, "email")
}
}
if result.Role == access.RoleUser {
configured, err := s.credentials.HasValidRecoveryCode(user.ID)
if err != nil {
return nil, ErrUnavailable
}
if configured {
result.Methods = append(result.Methods, "security_code")
}
}
if len(result.Methods) == 0 {
return result, nil
}
token, err := newTicketID()
if err != nil {
return nil, err
}
s.mu.Lock()
defer s.mu.Unlock()
s.cleanupLocked(s.now())
if len(s.publicTickets) >= maxRecoveryTickets {
return nil, ErrUnavailable
}
item.ExpiresAt = s.now().Add(decoyChallengeTTL)
s.publicTickets[ticketKey(token)] = item
result.Token = token
return result, nil
}
// lockPublicFlow 占用当前步骤,防止验证码发送、核销和密码提交并发复用。
func (s *Service) lockPublicFlow(token string) (*publicTicket, error) {
if s == nil || strings.TrimSpace(token) == "" {
return nil, ErrRecoveryDenied
}
s.mu.Lock()
defer s.mu.Unlock()
s.cleanupLocked(s.now())
item := s.publicTickets[ticketKey(token)]
if item == nil || !item.Flow || item.Verified || item.Busy {
return nil, ErrRecoveryExpired
}
item.Busy = true
return item, nil
}
func (s *Service) releasePublicFlow(token string, item *publicTicket) {
s.mu.Lock()
defer s.mu.Unlock()
if s.publicTickets[ticketKey(token)] == item {
item.Busy = false
}
}
func (s *Service) publicFlowIdentity(item *publicTicket) (string, error) {
var user models.User
found, err := s.engine.ID(item.UserID).Get(&user)
if err != nil {
return "", ErrUnavailable
}
if !found || user.Disabled != 0 || user.EffectiveRole() == access.RoleSuperAdmin || user.EffectiveRole() != item.Role || user.SecurityVersion != item.SecurityVersion || user.SessionVersion != item.SessionVersion {
return "", ErrRecoveryDenied
}
if item.CredentialID == 0 {
return "", nil
}
binding, err := s.external.FindVerifiedByID(user.ID, item.CredentialID)
if err != nil || binding.CredentialVersion != item.CredentialVersion {
return "", ErrRecoveryDenied
}
return s.external.Decrypt(*binding)
}
func (s *Service) SendPublicFlowCode(token, remoteIP string) error {
item, err := s.lockPublicFlow(token)
if err != nil {
return err
}
defer s.releasePublicFlow(token, item)
email, err := s.publicFlowIdentity(item)
if err != nil {
return err
}
if email == "" || s.verification == nil {
return ErrRecoveryDenied
}
challenge, err := s.verification.Issue(verification.IssueRequest{
Purpose: verification.PurposePasswordRecover, UserID: item.UserID, Account: item.Account,
Email: email, ResourceID: item.CredentialID, CredentialVersion: item.CredentialVersion,
BrowserTransaction: token,
}, remoteIP)
if err != nil {
return err
}
s.mu.Lock()
item.ChallengeID = challenge.ID
s.mu.Unlock()
return nil
}
func (s *Service) VerifyPublicFlow(token, method, code, remoteIP string) (string, error) {
item, err := s.lockPublicFlow(token)
if err != nil {
return "", err
}
defer s.releasePublicFlow(token, item)
email, err := s.publicFlowIdentity(item)
if err != nil {
return "", err
}
// 提前生成下一步令牌,避免随机源失败导致已核销安全码无法继续。
next, err := newTicketID()
if err != nil {
return "", err
}
switch method {
case "email":
if email == "" || item.ChallengeID == "" || s.verification == nil {
err = ErrRecoveryDenied
} else {
err = s.verification.VerifyBoundWithContext(item.ChallengeID, item.Account, email, strings.TrimSpace(code), verification.PurposePasswordRecover, item.CredentialID, remoteIP, token)
}
case "security_code":
if item.Role != access.RoleUser {
err = ErrRecoveryDenied
} else {
err = s.credentials.ConsumeRecoveryCode(item.UserID, code)
}
default:
err = ErrRecoveryDenied
}
if err != nil {
if errors.Is(err, password.ErrBusy) {
return "", err
}
s.mu.Lock()
item.Attempts++
if item.Attempts >= maxPublicRecoveryCodeAttempts {
delete(s.publicTickets, ticketKey(token))
}
s.mu.Unlock()
return "", ErrRecoveryDenied
}
s.mu.Lock()
defer s.mu.Unlock()
if s.publicTickets[ticketKey(token)] != item || !s.now().Before(item.ExpiresAt) {
return "", ErrRecoveryExpired
}
delete(s.publicTickets, ticketKey(token))
item.Verified, item.Method, item.Busy = true, method, false
item.ExpiresAt = s.now().Add(authorizationTTL)
s.publicTickets[ticketKey(next)] = item
return next, nil
}
@@ -0,0 +1,253 @@
package recovery
import (
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/access"
"git.pcux.cn/xuans/Smail/services/verification"
"git.pcux.cn/xuans/Smail/utils/password"
)
func TestPublicFlowEmailResetAndRoleBoundary(t *testing.T) {
for _, role := range []access.Role{access.RoleSuperAdmin, access.RoleAdmin, access.RoleUser} {
t.Run(string(role), func(t *testing.T) {
s, verify, engine, user := newRecoveryFixture(t)
user.Role = string(role)
if _, err := engine.ID(user.ID).Cols("role").Update(user); err != nil {
t.Fatal(err)
}
var code string
verify.Send = func(_ verification.Challenge, value string) error { code = value; return nil }
flow, err := s.IdentifyPublicFlow(user.Account)
if err != nil {
t.Fatal(err)
}
if role == access.RoleSuperAdmin {
if flow.Token != "" || len(flow.Methods) != 0 || flow.Email != "" {
t.Fatal("super administrator received public recovery access")
}
return
}
if flow.Email != "a***@example.com" || flow.Role != role {
t.Fatalf("unexpected identity: %#v", flow)
}
if err := s.CompletePublicFlow(flow.Token, "NewPass123"); err == nil {
t.Fatal("reset before verification")
}
if err := s.CompletePublicLink(flow.Token, "NewPass123", ""); err == nil {
t.Fatal("flow accepted by legacy completion")
}
if err := s.SendPublicFlowCode(flow.Token, "192.0.2.1"); err != nil {
t.Fatal(err)
}
if len(code) != 8 {
t.Fatal("email code not delivered")
}
if _, err := s.VerifyPublicFlow(flow.Token, "email", "bad-code", "192.0.2.1"); err == nil {
t.Fatal("invalid code accepted")
}
ticket, err := s.VerifyPublicFlow(flow.Token, "email", code, "192.0.2.1")
if err != nil {
t.Fatal(err)
}
if ticket == flow.Token {
t.Fatal("verification token not rotated")
}
if _, err := s.VerifyPublicFlow(flow.Token, "email", code, "192.0.2.1"); err == nil {
t.Fatal("verification replay accepted")
}
if err := s.CompletePublicFlow(ticket, "short"); err == nil {
t.Fatal("invalid password accepted")
}
if err := s.CompletePublicFlow(ticket, "NewPass123"); err != nil {
t.Fatal(err)
}
if err := s.CompletePublicFlow(ticket, "OtherPass12"); err == nil {
t.Fatal("ticket replay accepted")
}
var updated models.User
if _, err := engine.ID(user.ID).Get(&updated); err != nil {
t.Fatal(err)
}
if ok, err := password.Check(updated.Password, "NewPass123"); err != nil || !ok {
t.Fatal("new password not applied", err)
}
if updated.SessionVersion != user.SessionVersion+1 {
t.Fatal("old sessions still valid")
}
})
}
}
func TestPublicFlowSecurityCodeRoleAndFailureLimits(t *testing.T) {
for _, role := range []access.Role{access.RoleAdmin, access.RoleUser} {
t.Run(string(role), func(t *testing.T) {
s, _, engine, user := newRecoveryFixture(t)
user.Role = string(role)
if _, err := engine.ID(user.ID).Cols("role").Update(user); err != nil {
t.Fatal(err)
}
codes, err := s.credentials.GenerateRecoveryCodes(user.ID, 5)
if err != nil {
t.Fatal(err)
}
flow, err := s.IdentifyPublicFlow(user.Account)
if err != nil {
t.Fatal(err)
}
ticket, err := s.VerifyPublicFlow(flow.Token, "security_code", codes[0], "192.0.2.2")
if role == access.RoleAdmin {
if err == nil || strings.Contains(strings.Join(flow.Methods, ","), "security_code") {
t.Fatal("admin used security code instead of email")
}
return
}
if err != nil {
t.Fatal(err)
}
if err := s.CompletePublicFlow(ticket, "NewPass123"); err != nil {
t.Fatal(err)
}
flow, err = s.IdentifyPublicFlow(user.Account)
if err != nil {
t.Fatal(err)
}
for i := 0; i < maxPublicRecoveryCodeAttempts; i++ {
if _, err := s.VerifyPublicFlow(flow.Token, "security_code", "invalid", "192.0.2.2"); err == nil {
t.Fatal("bad code accepted")
}
}
if err := s.SendPublicFlowCode(flow.Token, "192.0.2.2"); err == nil {
t.Fatal("exhausted flow usable")
}
})
}
}
func TestPublicFlowRejectsExpiredAndChangedAccount(t *testing.T) {
for _, scenario := range []string{"expired", "disabled", "promoted", "security_version", "email_disabled"} {
t.Run(scenario, func(t *testing.T) {
s, verify, engine, user := newRecoveryFixture(t)
verify.Send = func(verification.Challenge, string) error { t.Fatal("sent code after invalidation"); return nil }
flow, err := s.IdentifyPublicFlow(user.Account)
if err != nil {
t.Fatal(err)
}
switch scenario {
case "expired":
now := s.now()
s.now = func() time.Time { return now.Add(20 * time.Minute) }
case "disabled":
user.Disabled = 1
_, err = engine.ID(user.ID).Cols("disabled").Update(user)
case "promoted":
user.Role = string(access.RoleSuperAdmin)
_, err = engine.ID(user.ID).Cols("role").Update(user)
case "security_version":
user.SecurityVersion++
_, err = engine.ID(user.ID).Cols("security_version").Update(user)
case "email_disabled":
binding, lookup := s.external.FindVerifiedPrimaryByUser(user.ID)
if lookup != nil {
t.Fatal(lookup)
}
err = s.external.Disable(user.ID, binding.ID)
}
if err != nil {
t.Fatal(err)
}
if err := s.SendPublicFlowCode(flow.Token, "192.0.2.3"); err == nil {
t.Fatal("invalidated flow accepted")
}
})
}
}
func TestPublicFlowRejectsCrossFlowCodeAndConcurrentUse(t *testing.T) {
s, verify, _, user := newRecoveryFixture(t)
first, err := s.IdentifyPublicFlow(user.Account)
if err != nil {
t.Fatal(err)
}
second, err := s.IdentifyPublicFlow(user.Account)
if err != nil {
t.Fatal(err)
}
started, release := make(chan struct{}), make(chan struct{})
var code string
verify.Send = func(_ verification.Challenge, value string) error {
code = value
close(started)
<-release
return nil
}
done := make(chan error, 1)
go func() { done <- s.SendPublicFlowCode(first.Token, "192.0.2.4") }()
<-started
_, concurrentErr := s.VerifyPublicFlow(first.Token, "email", code, "192.0.2.4")
close(release)
if err := <-done; err != nil {
t.Fatal(err)
}
if concurrentErr == nil {
t.Fatal("verification accepted while delivery was in progress")
}
// 即使另一流程取得挑战编号,也不能跨流程使用邮件验证码。
s.publicTickets[ticketKey(second.Token)].ChallengeID = s.publicTickets[ticketKey(first.Token)].ChallengeID
if _, err := s.VerifyPublicFlow(second.Token, "email", code, "192.0.2.4"); err == nil {
t.Fatal("cross-flow email code accepted")
}
if _, err := s.VerifyPublicFlow(first.Token, "email", code, "192.0.2.4"); err != nil {
t.Fatal(err)
}
}
func TestPublicFlowRechecksAccountAfterVerification(t *testing.T) {
for _, scenario := range []string{"expired", "disabled", "promoted", "security_version", "email_disabled"} {
t.Run(scenario, func(t *testing.T) {
s, verify, engine, user := newRecoveryFixture(t)
var code string
verify.Send = func(_ verification.Challenge, value string) error { code = value; return nil }
flow, err := s.IdentifyPublicFlow(user.Account)
if err != nil {
t.Fatal(err)
}
if err := s.SendPublicFlowCode(flow.Token, "192.0.2.5"); err != nil {
t.Fatal(err)
}
token, err := s.VerifyPublicFlow(flow.Token, "email", code, "192.0.2.5")
if err != nil {
t.Fatal(err)
}
switch scenario {
case "expired":
now := s.now()
s.now = func() time.Time { return now.Add(20 * time.Minute) }
case "disabled":
user.Disabled = 1
_, err = engine.ID(user.ID).Cols("disabled").Update(user)
case "promoted":
user.Role = string(access.RoleSuperAdmin)
_, err = engine.ID(user.ID).Cols("role").Update(user)
case "security_version":
user.SecurityVersion++
_, err = engine.ID(user.ID).Cols("security_version").Update(user)
case "email_disabled":
binding, lookup := s.external.FindVerifiedPrimaryByUser(user.ID)
if lookup != nil {
t.Fatal(lookup)
}
err = s.external.Disable(user.ID, binding.ID)
}
if err != nil {
t.Fatal(err)
}
if err := s.CompletePublicFlow(token, "NewPass123"); err == nil {
t.Fatal("password changed after account or verification invalidation")
}
})
}
}
+24 -6
View File
@@ -20,6 +20,10 @@ type PublicLinkDelivery func(email, token string) error
// publicTicket 只保存在进程内存中,map key 为令牌摘要而非令牌明文。
type publicTicket struct {
Flow bool
Verified bool
Method string
ChallengeID string
UserID int
Account string
Role access.Role
@@ -115,6 +119,14 @@ func (s *Service) PublicLinkRequiresRecoveryCode(token string) (bool, error) {
// CompletePublicLink 在同一数据库事务中完成管理员恢复码核销、密码更新和旧凭据撤销。
func (s *Service) CompletePublicLink(token, newPassword, recoveryCode string) error {
return s.completePublicLink(token, newPassword, recoveryCode, false)
}
func (s *Service) CompletePublicFlow(token, newPassword string) error {
return s.completePublicLink(token, newPassword, "", true)
}
func (s *Service) completePublicLink(token, newPassword, recoveryCode string, flow bool) error {
defer clearString(&newPassword)
defer clearString(&recoveryCode)
if s == nil || s.engine == nil || s.external == nil || s.credentials == nil || strings.TrimSpace(token) == "" {
@@ -135,6 +147,10 @@ func (s *Service) CompletePublicLink(token, newPassword, recoveryCode string) er
s.mu.Unlock()
return ErrRecoveryDenied
}
if item.Flow != flow || (flow && (!item.Verified || (item.Role == access.RoleAdmin && item.Method != "email"))) {
s.mu.Unlock()
return ErrRecoveryDenied
}
item.Busy = true
s.mu.Unlock()
@@ -159,13 +175,15 @@ func (s *Service) CompletePublicLink(token, newPassword, recoveryCode string) er
consume = true
return ErrRecoveryDenied
}
binding, err := s.external.FindVerifiedByID(item.UserID, item.CredentialID)
if err != nil || binding.CredentialVersion != item.CredentialVersion {
consume = true
return ErrRecoveryDenied
if !flow || item.Method == "email" {
binding, err := s.external.FindVerifiedByID(item.UserID, item.CredentialID)
if err != nil || binding.CredentialVersion != item.CredentialVersion {
consume = true
return ErrRecoveryDenied
}
}
if user.EffectiveRole() == access.RoleAdmin {
if !flow && user.EffectiveRole() == access.RoleAdmin {
if strings.TrimSpace(recoveryCode) == "" {
if s.recordPublicRecoveryCodeFailure(key, item) {
consume = true
@@ -202,7 +220,7 @@ func (s *Service) CompletePublicLink(token, newPassword, recoveryCode string) er
_ = session.Rollback()
}
}()
if user.EffectiveRole() == access.RoleAdmin {
if !flow && user.EffectiveRole() == access.RoleAdmin {
if err := s.credentials.ConsumeRecoveryCodeWithSession(session, user.ID, recoveryCode); err != nil {
if errors.Is(err, password.ErrBusy) {
return err
+3
View File
@@ -399,6 +399,9 @@ func (s *Service) CompleteWithContext(ticketID, newPassword, browserContext stri
if err != nil || !has || user.Disabled != 0 || user.EffectiveRole() == access.RoleSuperAdmin || user.SessionVersion != item.SessionVersion {
return ErrRecoveryDenied
}
if user.EffectiveRole() == access.RoleAdmin && item.Method != "email_admin" {
return ErrRecoveryDenied
}
if item.Method == "email" || item.Method == "email_admin" {
if user.EffectiveRole() == access.RoleAdmin && item.Method != "email_admin" {
return ErrRecoveryDenied