Files
Smail/backend/services/recovery/public_link.go
T

249 lines
7.1 KiB
Go

package recovery
import (
"fmt"
"strings"
"time"
"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/utils/password"
)
const maxPublicRecoveryCodeAttempts = 5
// PublicLinkDelivery 投递匿名恢复入口的一次性链接令牌。
// token 仅在调用期间存在,调用方不得写入日志或持久化。
type PublicLinkDelivery func(email, token string) error
// publicTicket 只保存在进程内存中,map key 为令牌摘要而非令牌明文。
type publicTicket struct {
UserID int
Account string
Role access.Role
SessionVersion int
SecurityVersion int
CredentialID int
CredentialVersion int
ExpiresAt time.Time
Attempts int
Busy bool
}
// BeginPublicLink 为非超级管理员生成独立匿名恢复链接。
// 为避免账户枚举,调用方应将所有错误映射为同一已受理响应。
func (s *Service) BeginPublicLink(identifier string) error {
if s == nil || s.engine == nil || s.external == nil {
return ErrUnavailable
}
account, err := auth.NormalizeIdentifier(identifier)
if err != nil || account == "" {
return ErrRecoveryDenied
}
var user models.User
has, err := s.engine.Where("account = ? AND disabled = 0", account).Get(&user)
if err != nil || !has || user.EffectiveRole() == access.RoleSuperAdmin {
return ErrRecoveryDenied
}
binding, err := s.external.FindVerifiedPrimaryByUser(user.ID)
if err != nil {
return ErrRecoveryDenied
}
email, err := s.external.Decrypt(*binding)
if err != nil || strings.TrimSpace(email) == "" {
return ErrRecoveryDenied
}
token, err := newTicketID()
if err != nil {
return err
}
key := ticketKey(token)
s.mu.Lock()
s.cleanupLocked(s.now())
delivery := s.publicDelivery
if delivery == nil || len(s.publicTickets) >= maxRecoveryTickets {
s.mu.Unlock()
return ErrUnavailable
}
for ticketKey, item := range s.publicTickets {
if item.UserID == user.ID {
// 正在提交的旧链接优先完成,期间不签发会与其竞争的新链接。
// 调用方统一隐藏该结果,因此不会泄露账户或链接状态。
if item.Busy {
s.mu.Unlock()
return ErrRecoveryDenied
}
delete(s.publicTickets, ticketKey)
}
}
s.publicTickets[key] = &publicTicket{
UserID: user.ID, Account: user.Account, Role: user.EffectiveRole(),
SessionVersion: user.SessionVersion, SecurityVersion: user.SecurityVersion,
CredentialID: binding.ID, CredentialVersion: binding.CredentialVersion,
ExpiresAt: s.now().Add(authorizationTTL),
}
s.mu.Unlock()
if err := delivery(email, token); err != nil {
s.mu.Lock()
delete(s.publicTickets, key)
s.mu.Unlock()
return fmt.Errorf("deliver public recovery link: %w", err)
}
return nil
}
// PublicLinkRequiresRecoveryCode 返回当前一次性链接是否属于管理员。
// 此方法只为恢复页决定是否展示恢复码字段;令牌必须由收件人持有,且不会返回账号或角色详情。
func (s *Service) PublicLinkRequiresRecoveryCode(token string) (bool, error) {
if s == nil || strings.TrimSpace(token) == "" {
return false, ErrInvalidRequest
}
key := ticketKey(token)
s.mu.Lock()
defer s.mu.Unlock()
s.cleanupLocked(s.now())
item, ok := s.publicTickets[key]
if !ok || item.Busy {
return false, ErrRecoveryExpired
}
return item.Role == access.RoleAdmin, nil
}
// CompletePublicLink 在同一数据库事务中完成管理员恢复码核销、密码更新和旧凭据撤销。
func (s *Service) CompletePublicLink(token, newPassword, recoveryCode string) error {
defer clearString(&newPassword)
defer clearString(&recoveryCode)
if s == nil || s.engine == nil || s.external == nil || s.credentials == nil || strings.TrimSpace(token) == "" {
return ErrInvalidRequest
}
if password.ValidateUserPassword(newPassword) != nil {
return ErrInvalidNewPassword
}
key := ticketKey(token)
s.mu.Lock()
s.cleanupLocked(s.now())
item, ok := s.publicTickets[key]
if !ok {
s.mu.Unlock()
return ErrRecoveryExpired
}
if item.Busy {
s.mu.Unlock()
return ErrRecoveryDenied
}
item.Busy = true
s.mu.Unlock()
consume := false
defer func() {
s.mu.Lock()
defer s.mu.Unlock()
if s.publicTickets[key] != item {
return
}
if consume || !s.now().Before(item.ExpiresAt) {
delete(s.publicTickets, key)
return
}
item.Busy = false
}()
var user models.User
has, err := s.engine.ID(item.UserID).Get(&user)
if err != nil || !has || user.Disabled != 0 || user.EffectiveRole() == access.RoleSuperAdmin ||
user.EffectiveRole() != item.Role || user.SessionVersion != item.SessionVersion || user.SecurityVersion != item.SecurityVersion {
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 user.EffectiveRole() == access.RoleAdmin {
if strings.TrimSpace(recoveryCode) == "" {
if s.recordPublicRecoveryCodeFailure(key, item) {
consume = true
}
return ErrRecoveryDenied
}
}
hash, err := auth.HashPassword(newPassword)
if err != nil {
return err
}
defer clearString(&hash)
version := user.SessionVersion + 1
if version <= 0 {
version = 1
}
securityVersion := user.SecurityVersion + 1
if securityVersion <= 0 {
securityVersion = 1
}
now := s.now().UTC()
session := s.engine.NewSession()
if session == nil {
return ErrUnavailable
}
defer session.Close()
if err := session.Begin(); err != nil {
return err
}
committed := false
defer func() {
if !committed {
_ = session.Rollback()
}
}()
if user.EffectiveRole() == access.RoleAdmin {
if err := s.credentials.ConsumeRecoveryCodeWithSession(session, user.ID, recoveryCode); err != nil {
if s.recordPublicRecoveryCodeFailure(key, item) {
consume = true
}
return ErrRecoveryDenied
}
}
if affected, err := session.ID(item.UserID).Where("session_version = ? AND security_version = ? AND disabled = 0", item.SessionVersion, item.SecurityVersion).
Cols("password", "session_version", "security_version", "must_change_password", "password_changed_at").Update(&models.User{
Password: hash, SessionVersion: version, SecurityVersion: securityVersion, MustChangePassword: 0, PasswordChangedAt: &now,
}); err != nil {
return err
} else if affected != 1 {
consume = true
return ErrRecoveryDenied
}
if err := s.credentials.RevokeAllWithSession(session, item.UserID); err != nil {
return err
}
if err := session.Commit(); err != nil {
return err
}
committed = true
consume = true
s.InvalidateUser(item.UserID)
if s.verification != nil && s.verification.Store != nil {
_ = s.verification.Store.InvalidateAccount(user.Account)
}
s.invalidateSecurityState(item.UserID, user.Account)
return nil
}
func (s *Service) recordPublicRecoveryCodeFailure(key string, item *publicTicket) bool {
if s == nil || item == nil {
return true
}
s.mu.Lock()
defer s.mu.Unlock()
if s.publicTickets[key] != item {
return true
}
item.Attempts++
return item.Attempts >= maxPublicRecoveryCodeAttempts
}