强制超级管理员配置安全验证并保护本机密码重置
Security Checks / security (push) Waiting to run

This commit is contained in:
xuans committed 2026-09-19 00:24:27 +08:00
1 parent de8c298bd5
commit 67931eab5d
38 files changed
+1128 -135

No files matched your search

+77 -7
View File
@@ -3,17 +3,37 @@ package adminreset
import (
"context"
"encoding/json"
"errors"
"fmt"
"net"
"strconv"
"strings"
"time"
)
func SendReset(ctx context.Context, conn net.Conn, password string) error {
if conn == nil || password == "" {
var (
ErrVerificationUnavailable = errors.New("no verification method available")
ErrVerificationFailed = errors.New("verification failed")
)
func responseError(code string) error {
switch code {
case "VERIFICATION_UNAVAILABLE":
return ErrVerificationUnavailable
case "VERIFICATION_FAILED":
return ErrVerificationFailed
case "REPLAY_OR_EXPIRED":
return ErrExpiredSession
default:
return ErrInvalidRequest
}
defer clearPassword(&password)
deadline := time.Now().Add(10 * time.Second)
}
func SendVerifiedReset(ctx context.Context, conn net.Conn, input func(string) (string, error), readPassword func() (string, error)) error {
if conn == nil || input == nil || readPassword == nil {
return ErrInvalidRequest
}
deadline := time.Now().Add(controlRequestTimeout)
if contextDeadline, ok := ctx.Deadline(); ok && contextDeadline.Before(deadline) {
deadline = contextDeadline
}
@@ -22,10 +42,60 @@ func SendReset(ctx context.Context, conn net.Conn, password string) error {
}
defer conn.SetDeadline(time.Time{})
challenge, err := DecodeResponse(conn)
if err != nil || !challenge.OK || challenge.Code != "CHALLENGE" || challenge.Nonce == "" {
if err != nil {
return err
}
if !challenge.OK {
return responseError(challenge.Code)
}
if challenge.Code != "CHALLENGE" || challenge.Nonce == "" {
return ErrInvalidRequest
}
if err := json.NewEncoder(conn).Encode(Request{Version: ProtocolVersion, Nonce: challenge.Nonce, NewPassword: password}); err != nil {
var prompt strings.Builder
prompt.WriteString("请选择安全验证方式(输入序号;选择邮箱即发送验证码):")
for i, method := range challenge.Methods {
fmt.Fprintf(&prompt, " %d.%s", i+1, method.Label)
}
choice, err := input(prompt.String())
if err != nil {
return err
}
index, err := strconv.Atoi(strings.TrimSpace(choice))
if err != nil || index < 1 || index > len(challenge.Methods) {
return ErrInvalidRequest
}
exchange := func(request Request) error {
request.Version, request.Nonce = ProtocolVersion, challenge.Nonce
if err := json.NewEncoder(conn).Encode(request); err != nil {
return err
}
response, err := DecodeResponse(conn)
if err != nil {
return err
}
if !response.OK {
return responseError(response.Code)
}
return nil
}
if err := exchange(Request{Action: "select", Method: challenge.Methods[index-1].ID}); err != nil {
return err
}
code, err := input("请输入所选方式的验证码或安全码")
if err != nil {
return err
}
err = exchange(Request{Action: "verify", Code: code})
clearPassword(&code)
if err != nil {
return err
}
value, err := readPassword()
if err != nil {
return err
}
defer clearPassword(&value)
if err := json.NewEncoder(conn).Encode(Request{Version: ProtocolVersion, Nonce: challenge.Nonce, Action: "reset", NewPassword: value}); err != nil {
return fmt.Errorf("send reset request: %w", err)
}
response, err := DecodeResponse(conn)
@@ -33,7 +103,7 @@ func SendReset(ctx context.Context, conn net.Conn, password string) error {
return fmt.Errorf("read reset response: %w", err)
}
if !response.OK {
return fmt.Errorf("reset rejected: %s", response.Code)
return responseError(response.Code)
}
return nil
}
+49
View File
@@ -0,0 +1,49 @@
package adminreset
import (
"context"
"net"
)
// 协议测试使用固定凭据夹具;生产验证在独立数据库集成测试中覆盖。
type testResetFlow struct {
reset func(string) error
selected, verified bool
}
func (f *testResetFlow) Methods() []Method { return []Method{{ID: "fixture", Label: "测试验证"}} }
func (f *testResetFlow) Start(method string) error {
if method != "fixture" {
return ErrInvalidRequest
}
f.selected = true
return nil
}
func (f *testResetFlow) Verify(code string) error {
if !f.selected || code != "fixture-code" {
return ErrInvalidRequest
}
f.verified = true
return nil
}
func (f *testResetFlow) Reset(value string) error {
if !f.verified {
return ErrInvalidRequest
}
f.verified = false
return f.reset(value)
}
func (f *testResetFlow) Close() {}
func testResetHandler(reset func(string) error) ResetHandler {
return func() (ResetSession, error) { return &testResetFlow{reset: reset}, nil }
}
func SendReset(ctx context.Context, conn net.Conn, value string) error {
step := 0
return SendVerifiedReset(ctx, conn, func(string) (string, error) {
step++
if step == 1 {
return "1", nil
}
return "fixture-code", nil
}, func() (string, error) { return value, nil })
}
+11 -3
View File
@@ -30,6 +30,17 @@ func ReadProtectedPassword() (string, error) {
}
func askPassword(prompt string) (string, error) {
value, err := ReadProtectedInput(prompt)
if err != nil {
return "", err
}
if password.ValidateUserPassword(value) != nil {
return "", errors.New("密码长度无效")
}
return value, nil
}
func ReadProtectedInput(prompt string) (string, error) {
command := exec.Command("systemd-ask-password", "--no-tty", prompt)
command.Stderr = io.Discard
output, err := command.Output()
@@ -39,9 +50,6 @@ func askPassword(prompt string) (string, error) {
output = stripPasswordLineEnding(output)
value := string(output)
defer clearBytes(output)
if password.ValidateUserPassword(value) != nil {
return "", errors.New("密码长度无效")
}
return value, nil
}
@@ -2,4 +2,5 @@
package adminreset
func ReadProtectedPassword() (string, error) { return "", ErrUnsupported }
func ReadProtectedPassword() (string, error) { return "", ErrUnsupported }
func ReadProtectedInput(string) (string, error) { return "", ErrUnsupported }
@@ -35,6 +35,20 @@ func ReadProtectedPassword() (string, error) {
}
func readWindowsPassword(prompt string) (string, error) {
value, err := ReadProtectedInput(prompt)
if err != nil {
return "", err
}
if password.ValidateUserPassword(value) != nil {
return "", errors.New("密码长度必须为 8 到 12 个字符")
}
return value, nil
}
func ReadProtectedInput(prompt string) (string, error) {
if !term.IsTerminal(int(os.Stdin.Fd())) {
return "", errors.New("安全验证需要交互式控制台")
}
fmt.Fprint(os.Stderr, prompt+": ")
value, err := term.ReadPassword(int(os.Stdin.Fd()))
fmt.Fprintln(os.Stderr)
@@ -45,8 +59,5 @@ func readWindowsPassword(prompt string) (string, error) {
for i := range value {
value[i] = 0
}
if password.ValidateUserPassword(normalized) != nil {
return "", errors.New("密码长度必须为 8 到 12 个字符")
}
return normalized, nil
}
+70 -11
View File
@@ -17,9 +17,9 @@ import (
)
const (
ProtocolVersion = 1
ProtocolVersion = 2
maxControlMessageSize = 16 << 10
controlRequestTimeout = 15 * time.Second
controlRequestTimeout = 5 * time.Minute
defaultSessionCapacity = 128
)
@@ -36,16 +36,33 @@ type Request struct {
Version int `json:"version"`
Nonce string `json:"nonce"`
NewPassword string `json:"new_password"`
Action string `json:"action"`
Method string `json:"method,omitempty"`
Code string `json:"code,omitempty"`
}
type Response struct {
OK bool `json:"ok"`
Code string `json:"code,omitempty"`
Message string `json:"message,omitempty"`
Nonce string `json:"nonce,omitempty"`
OK bool `json:"ok"`
Code string `json:"code,omitempty"`
Message string `json:"message,omitempty"`
Nonce string `json:"nonce,omitempty"`
Methods []Method `json:"methods,omitempty"`
}
type ResetHandler func(newPassword string) error
type Method struct {
ID string `json:"id"`
Label string `json:"label"`
}
type ResetSession interface {
Methods() []Method
Start(string) error
Verify(string) error
Reset(string) error
Close()
}
type ResetHandler func() (ResetSession, error)
type SessionGuard struct {
mu sync.Mutex
@@ -154,7 +171,23 @@ func DecodeRequest(r io.Reader) (Request, error) {
if err := decodeControlJSON(data, &request); err != nil {
return Request{}, ErrInvalidRequest
}
if request.Version != ProtocolVersion || strings.TrimSpace(request.Nonce) == "" || password.ValidateUserPassword(request.NewPassword) != nil {
if request.Version != ProtocolVersion || strings.TrimSpace(request.Nonce) == "" {
return Request{}, ErrInvalidRequest
}
switch request.Action {
case "select":
if request.Method == "" || request.Code != "" || request.NewPassword != "" {
return Request{}, ErrInvalidRequest
}
case "verify":
if request.Code == "" || len(request.Code) > 128 || request.Method != "" || request.NewPassword != "" {
return Request{}, ErrInvalidRequest
}
case "reset":
if request.Code != "" || request.Method != "" || password.ValidateUserPassword(request.NewPassword) != nil {
return Request{}, ErrInvalidRequest
}
default:
return Request{}, ErrInvalidRequest
}
return request, nil
@@ -221,11 +254,37 @@ func handleResetConnection(conn io.ReadWriter, setDeadline func(time.Time) error
return
}
defer guard.Discard(nonce)
if err := EncodeResponse(conn, Response{OK: true, Code: "CHALLENGE", Nonce: nonce}); err != nil {
flow, err := handler()
if err != nil || flow == nil {
_ = EncodeResponse(conn, Response{Code: "VERIFICATION_UNAVAILABLE", Message: "暂无可用安全验证,请先登录安全中心配置邮箱、手机动态码或安全码"})
return
}
defer flow.Close()
if err := EncodeResponse(conn, Response{OK: true, Code: "CHALLENGE", Nonce: nonce, Methods: flow.Methods()}); err != nil {
return
}
for _, action := range []string{"select", "verify"} {
request, err := DecodeRequest(conn)
if err != nil || request.Nonce != nonce || request.Action != action {
_ = EncodeResponse(conn, Response{Code: "INVALID_REQUEST", Message: "验证步骤无效,请重新启动重置"})
return
}
if action == "select" {
err = flow.Start(request.Method)
} else {
err = flow.Verify(request.Code)
}
clearPassword(&request.Code)
if err != nil {
_ = EncodeResponse(conn, Response{Code: "VERIFICATION_FAILED", Message: "安全验证失败、已过期或请求过于频繁,请稍后重试"})
return
}
if err := EncodeResponse(conn, Response{OK: true, Code: action}); err != nil {
return
}
}
request, err := DecodeRequest(conn)
if err != nil || request.Nonce != nonce {
if err != nil || request.Nonce != nonce || request.Action != "reset" {
_ = EncodeResponse(conn, Response{Code: "INVALID_REQUEST", Message: "重置请求无效"})
return
}
@@ -235,7 +294,7 @@ func handleResetConnection(conn io.ReadWriter, setDeadline func(time.Time) error
}
password := request.NewPassword
defer clearPassword(&password)
if err := handler(password); err != nil {
if err := flow.Reset(password); err != nil {
_ = EncodeResponse(conn, Response{Code: "RESET_FAILED", Message: "超级管理员密码重置失败"})
return
}
+6 -6
View File
@@ -80,9 +80,9 @@ func TestProtocolRejectsUnknownFieldsInvalidVersionAndTrailingData(t *testing.T)
func TestProtocolEnforcesUnifiedPasswordLength(t *testing.T) {
valid := []string{
`{"version":1,"nonce":"n","new_password":"12345678"}`,
`{"version":1,"nonce":"n","new_password":"123456789012"}`,
`{"version":1,"nonce":"n","new_password":"密码aa"}`,
`{"version":2,"action":"reset","nonce":"n","new_password":"12345678"}`,
`{"version":2,"action":"reset","nonce":"n","new_password":"123456789012"}`,
`{"version":2,"action":"reset","nonce":"n","new_password":"密码aa"}`,
}
for _, input := range valid {
if _, err := DecodeRequest(strings.NewReader(input)); err != nil {
@@ -91,9 +91,9 @@ func TestProtocolEnforcesUnifiedPasswordLength(t *testing.T) {
}
invalid := []string{
`{"version":1,"nonce":"n","new_password":"1234567"}`,
`{"version":1,"nonce":"n","new_password":"1234567890123"}`,
`{"version":1,"nonce":"n","new_password":"密码密码a"}`,
`{"version":2,"action":"reset","nonce":"n","new_password":"1234567"}`,
`{"version":2,"action":"reset","nonce":"n","new_password":"1234567890123"}`,
`{"version":2,"action":"reset","nonce":"n","new_password":"密码密码a"}`,
}
for _, input := range invalid {
if _, err := DecodeRequest(strings.NewReader(input)); !errors.Is(err, ErrInvalidRequest) {
+10 -1
View File
@@ -20,6 +20,10 @@ var (
// ResetSuperAdmin 在主程序内完成超级管理员密码重置事务。
// smail-admin 只负责通过本机 IPC 传递一次性请求,不直接访问数据库。
func ResetSuperAdmin(engine *xorm.Engine, newPassword string, invalidators ...func(userID int, account string)) error {
return resetSuperAdmin(engine, newPassword, nil, invalidators...)
}
func resetSuperAdmin(engine *xorm.Engine, newPassword string, authorize func(*xorm.Session, models.User) error, invalidators ...func(userID int, account string)) error {
if engine == nil || newPassword == "" {
return ErrInvalidRequest
}
@@ -65,6 +69,11 @@ func ResetSuperAdmin(engine *xorm.Engine, newPassword string, invalidators ...fu
return ErrSuperAdminAmbiguous
}
target := targets[0]
if authorize != nil {
if err := authorize(session, target); err != nil {
return err
}
}
version := target.SessionVersion + 1
if version <= 0 {
version = 1
@@ -81,7 +90,7 @@ func ResetSuperAdmin(engine *xorm.Engine, newPassword string, invalidators ...fu
MustChangePassword: 0,
PasswordChangedAt: &now,
}
affected, err := session.ID(target.ID).Where("session_version = ?", target.SessionVersion).Cols("password", "session_version", "security_version", "must_change_password", "password_changed_at").Update(updated)
affected, err := session.ID(target.ID).Where("session_version = ? AND security_version = ?", target.SessionVersion, target.SecurityVersion).Cols("password", "session_version", "security_version", "must_change_password", "password_changed_at").Update(updated)
if err != nil {
return fmt.Errorf("update super administrator: %w", err)
}
@@ -123,14 +123,14 @@ func TestUnixResetCommitsPasswordAndRevokesAllProtocolCodes(t *testing.T) {
done := make(chan error, 1)
invalidated := make(chan bool, 1)
go func() {
done <- server.Serve(ctx, func(value string) error {
done <- server.Serve(ctx, testResetHandler(func(value string) error {
return ResetSuperAdmin(engine, value, func(id int, account string) {
var committed models.User
found, err := engine.ID(id).Get(&committed)
invalidated <- err == nil && found && id == users[0].ID && account == users[0].Account &&
committed.SessionVersion == users[0].SessionVersion+1
})
}, NewSessionGuard(time.Minute))
}), NewSessionGuard(time.Minute))
}()
t.Cleanup(func() {
cancel()
@@ -24,7 +24,9 @@ func TestUnixResetRoundTrip(t *testing.T) {
defer cancel()
guard := NewSessionGuard(time.Minute)
called := make(chan string, 1)
go func() { _ = server.Serve(ctx, func(password string) error { called <- password; return nil }, guard) }()
go func() {
_ = server.Serve(ctx, testResetHandler(func(password string) error { called <- password; return nil }), guard)
}()
var conn net.Conn
for i := 0; i < 20; i++ {
conn, err = DialControl(context.Background(), path)
@@ -75,7 +77,10 @@ func TestUnixEmptyAllowedUIDsRejectConnection(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go func() {
_ = server.Serve(ctx, func(string) error { t.Error("unauthorized handler was called"); return nil }, NewSessionGuard(time.Minute))
_ = server.Serve(ctx, func() (ResetSession, error) {
t.Error("unauthorized handler was called")
return nil, ErrInvalidRequest
}, NewSessionGuard(time.Minute))
}()
conn, err := DialControl(context.Background(), path)
@@ -139,7 +144,7 @@ func TestUnixServerStopsWhenContextIsCancelled(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() {
done <- server.Serve(ctx, func(string) error { return nil }, NewSessionGuard(time.Minute))
done <- server.Serve(ctx, testResetHandler(func(string) error { return nil }), NewSessionGuard(time.Minute))
}()
cancel()
+1 -31
View File
@@ -116,37 +116,7 @@ func (s *UnixServer) handle(conn net.Conn, handler ResetHandler, guard *SessionG
_ = EncodeResponse(conn, Response{Code: "UNAUTHORIZED", Message: "本机调用者身份不受信任"})
return
}
_ = conn.SetDeadline(time.Now().Add(controlRequestTimeout))
defer conn.SetDeadline(time.Time{})
nonce, err := guard.Issue()
if err != nil {
_ = EncodeResponse(conn, Response{Code: "CHANNEL_UNAVAILABLE", Message: "重置通道不可用"})
return
}
defer guard.Discard(nonce)
if err := EncodeResponse(conn, Response{OK: true, Code: "CHALLENGE", Nonce: nonce}); err != nil {
return
}
request, err := DecodeRequest(conn)
if err != nil {
_ = EncodeResponse(conn, Response{Code: "INVALID_REQUEST", Message: "重置请求无效"})
return
}
if request.Nonce != nonce {
_ = EncodeResponse(conn, Response{Code: "INVALID_REQUEST", Message: "重置请求无效"})
return
}
if err := guard.Consume(request.Nonce); err != nil {
_ = EncodeResponse(conn, Response{Code: "REPLAY_OR_EXPIRED", Message: "重置会话已失效或已使用"})
return
}
password := request.NewPassword
defer clearPassword(&password)
if err := handler(password); err != nil {
_ = EncodeResponse(conn, Response{Code: "RESET_FAILED", Message: "超级管理员密码重置失败"})
return
}
_ = EncodeResponse(conn, Response{OK: true, Message: "超级管理员密码已重置"})
handleResetConnection(conn, conn.SetDeadline, handler, guard)
}
func (s *UnixServer) authorize(conn net.Conn) error {
@@ -21,7 +21,7 @@ func testPipePath(t *testing.T) string {
return fmt.Sprintf(`\\.\pipe\smail-admin-control-test-%d-%d`, os.Getpid(), time.Now().UnixNano())
}
func startWindowsTestServer(t *testing.T, handler ResetHandler) (string, context.CancelFunc, <-chan error) {
func startWindowsTestServer(t *testing.T, handler func(string) error) (string, context.CancelFunc, <-chan error) {
t.Helper()
if err := authorizeCurrentWindowsProcess(); err != nil {
t.Skip("Windows IPC tests require an elevated local administrator or SYSTEM token")
@@ -33,7 +33,7 @@ func startWindowsTestServer(t *testing.T, handler ResetHandler) (string, context
}
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() { done <- server.Serve(ctx, handler, NewSessionGuard(time.Minute)) }()
go func() { done <- server.Serve(ctx, testResetHandler(handler), NewSessionGuard(time.Minute)) }()
t.Cleanup(func() {
cancel()
_ = server.Close()
@@ -165,7 +165,9 @@ func TestWindowsServerStopsWhenContextIsCancelled(t *testing.T) {
}
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() { done <- server.Serve(ctx, func(string) error { return nil }, NewSessionGuard(time.Minute)) }()
go func() {
done <- server.Serve(ctx, testResetHandler(func(string) error { return nil }), NewSessionGuard(time.Minute))
}()
cancel()
select {
case err := <-done:
+278
View File
@@ -0,0 +1,278 @@
package adminreset
import (
"fmt"
"strings"
"sync"
"time"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/access"
"git.pcux.cn/xuans/Smail/services/credentials"
"git.pcux.cn/xuans/Smail/services/externalemail"
"git.pcux.cn/xuans/Smail/services/totp"
"git.pcux.cn/xuans/Smail/services/verification"
"git.pcux.cn/xuans/Smail/utils/password"
"xorm.io/xorm"
)
// VerificationService 的限流状态跨连接保留,不能通过重新启动客户端刷新尝试次数。
type VerificationService struct {
engine *xorm.Engine
email *externalemail.Repository
codes *credentials.Service
totp *totp.Service
verify *verification.Service
invalidate func(int, string)
mu sync.Mutex
attempts int
window time.Time
}
func NewVerificationService(engine *xorm.Engine, email *externalemail.Repository, codes *credentials.Service, authenticator *totp.Service, verify *verification.Service, invalidate func(int, string)) *VerificationService {
return &VerificationService{engine: engine, email: email, codes: codes, totp: authenticator, verify: verify, invalidate: invalidate}
}
type verifiedReset struct {
service *VerificationService
user models.User
methods []Method
emails map[string]models.ExternalEmail
authenticator models.TOTPAuthenticator
selected string
challenge verification.Challenge
context string
email string
recovery models.RecoveryCode
recoveryCode string
verified bool
expires time.Time
}
func (s *VerificationService) Begin() (ResetSession, error) {
if s == nil || s.engine == nil || s.email == nil || s.codes == nil || s.totp == nil || s.verify == nil {
return nil, ErrInvalidRequest
}
var users []models.User
if err := s.engine.Find(&users); err != nil {
return nil, err
}
var targets []models.User
for _, user := range users {
if user.EffectiveRole() == access.RoleSuperAdmin {
targets = append(targets, user)
}
}
if len(targets) != 1 || targets[0].Disabled != 0 {
return nil, ErrSuperAdminNotFound
}
flow := &verifiedReset{service: s, user: targets[0], emails: make(map[string]models.ExternalEmail), expires: time.Now().Add(controlRequestTimeout)}
items, err := s.email.List(flow.user.ID)
if err != nil {
return nil, err
}
for _, item := range items {
if item.Status != models.ExternalEmailStatusVerified {
continue
}
address, err := s.email.Decrypt(item)
if err != nil {
return nil, err
}
id := fmt.Sprintf("email:%d", item.ID)
flow.emails[id] = item
flow.methods = append(flow.methods, Method{ID: id, Label: "发送验证码到 " + address})
}
has, err := s.engine.Where("user_id = ? AND enabled = ? AND revoked_at IS NULL", flow.user.ID, true).Get(&flow.authenticator)
if err != nil {
return nil, err
}
if has {
flow.methods = append(flow.methods, Method{ID: "totp", Label: "手机验证器动态码"})
}
has, err = s.codes.HasValidRecoveryCode(flow.user.ID)
if err != nil {
return nil, err
}
if has {
flow.methods = append(flow.methods, Method{ID: "recovery", Label: "安全码"})
}
if len(flow.methods) == 0 {
return nil, ErrInvalidRequest
}
flow.context, err = NewNonce()
return flow, err
}
func (f *verifiedReset) Methods() []Method { return f.methods }
func (f *verifiedReset) Start(method string) error {
if f.selected != "" || !time.Now().Before(f.expires) {
return ErrInvalidRequest
}
available := false
for _, item := range f.methods {
if item.ID == method {
available = true
}
}
if !available {
return ErrInvalidRequest
}
f.selected = method
if item, ok := f.emails[method]; ok {
if err := f.checkCurrent(nil); err != nil {
return err
}
address, err := f.service.email.Decrypt(item)
if err != nil {
return err
}
f.email = address
f.challenge, err = f.service.verify.Issue(verification.IssueRequest{
Purpose: verification.PurposeAdminLocalReset, Account: f.user.Account, UserID: f.user.ID,
Email: address, ResourceID: item.ID, CredentialVersion: item.CredentialVersion,
BrowserTransaction: f.context, Environment: "local-ipc", TTL: controlRequestTimeout,
}, "local-ipc")
return err
}
return nil
}
func (s *VerificationService) allowAttempt() bool {
s.mu.Lock()
defer s.mu.Unlock()
if time.Since(s.window) >= 15*time.Minute {
s.window = time.Now()
s.attempts = 0
}
if s.attempts >= 5 {
return false
}
s.attempts++
return true
}
func (f *verifiedReset) Verify(code string) error {
if f.verified || f.selected == "" || !f.service.allowAttempt() {
return ErrInvalidRequest
}
if err := f.checkCurrent(nil); err != nil {
return err
}
var err error
switch f.selected {
case "totp":
err = f.service.totp.Verify(f.user.ID, strings.TrimSpace(code))
case "recovery":
code = strings.ToUpper(strings.TrimSpace(code))
if len(code) < 12 || len(code) > 64 {
return ErrInvalidRequest
}
var items []models.RecoveryCode
if err := f.service.engine.Where("user_id = ? AND used_at IS NULL", f.user.ID).Find(&items); err != nil {
return err
}
err = ErrInvalidRequest
for _, item := range items {
matched, checkErr := password.Check(item.CodeHash, code)
if checkErr != nil {
return checkErr
}
if matched {
f.recovery = item
f.recoveryCode = code
err = nil
break
}
}
default:
item, ok := f.emails[f.selected]
if !ok {
return ErrInvalidRequest
}
err = f.service.verify.VerifyBoundWithContext(f.challenge.ID, f.user.Account, f.email, strings.TrimSpace(code), verification.PurposeAdminLocalReset, item.ID, "local-ipc", f.context)
}
if err != nil {
f.Close()
return err
}
f.verified = true
return nil
}
// checkCurrent 同时绑定账号版本与所选凭据,验证后更换邮箱或撤销凭据不能继续重置。
func (f *verifiedReset) checkCurrent(tx *xorm.Session) error {
if !time.Now().Before(f.expires) {
return ErrExpiredSession
}
if tx == nil {
tx = f.service.engine.NewSession()
defer tx.Close()
}
var user models.User
found, err := tx.ID(f.user.ID).Get(&user)
if err != nil {
return err
}
if !found || user.Disabled != 0 || user.EffectiveRole() != access.RoleSuperAdmin || user.Account != f.user.Account || user.Password != f.user.Password || user.SessionVersion != f.user.SessionVersion || user.SecurityVersion != f.user.SecurityVersion {
return ErrInvalidRequest
}
if item, ok := f.emails[f.selected]; ok {
var current models.ExternalEmail
found, err := tx.ID(item.ID).Get(&current)
if err != nil {
return err
}
if !found || current.UserID != user.ID || current.Status != models.ExternalEmailStatusVerified || current.CredentialVersion != item.CredentialVersion || current.EmailCiphertext != item.EmailCiphertext {
return ErrInvalidRequest
}
} else if f.selected == "totp" {
var current models.TOTPAuthenticator
found, err := tx.ID(f.authenticator.ID).Get(&current)
if err != nil {
return err
}
if !found || current.UserID != user.ID || !current.Enabled || current.RevokedAt != nil || current.CredentialVersion != f.authenticator.CredentialVersion || current.SecretCiphertext != f.authenticator.SecretCiphertext {
return ErrInvalidRequest
}
} else if f.selected == "recovery" && f.verified {
var current models.RecoveryCode
found, err := tx.ID(f.recovery.ID).Get(&current)
if err != nil {
return err
}
if !found || current.UserID != user.ID || current.UsedAt != nil || current.CodeHash != f.recovery.CodeHash {
return ErrInvalidRequest
}
}
return nil
}
func (f *verifiedReset) Reset(value string) error {
if !f.verified {
return ErrInvalidRequest
}
defer f.Close()
return resetSuperAdmin(f.service.engine, value, func(tx *xorm.Session, target models.User) error {
if target.ID != f.user.ID {
return ErrInvalidRequest
}
if err := f.checkCurrent(tx); err != nil {
return err
}
if f.selected == "recovery" {
return f.service.codes.ConsumeRecoveryCodeWithSession(tx, target.ID, f.recoveryCode)
}
return nil
}, f.service.invalidate)
}
func (f *verifiedReset) Close() {
f.verified = false
f.expires = time.Time{}
clearPassword(&f.recoveryCode)
if f.challenge.ID != "" {
f.service.verify.Store.InvalidateChallenge(f.challenge.ID)
}
}
@@ -0,0 +1,302 @@
package adminreset
import (
"context"
"crypto/hmac"
"crypto/sha256"
"encoding/base32"
"encoding/binary"
"encoding/json"
"fmt"
"net"
"path/filepath"
"testing"
"time"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/auth"
"git.pcux.cn/xuans/Smail/services/credentials"
"git.pcux.cn/xuans/Smail/services/externalemail"
"git.pcux.cn/xuans/Smail/services/totp"
"git.pcux.cn/xuans/Smail/services/verification"
"git.pcux.cn/xuans/Smail/utils/password"
"xorm.io/xorm"
)
func verificationFixture(t *testing.T) (*VerificationService, models.User, *string) {
t.Helper()
engine, err := xorm.NewEngine("sqlite", filepath.Join(t.TempDir(), "verified-reset.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = engine.Close() })
if err := engine.Sync2(&models.User{}, &models.ExternalEmail{}, &models.TOTPAuthenticator{}, &models.SecurityQuestion{}, &models.RecoveryCode{}, &models.ProtocolCredential{}, &models.WebAuthnCredential{}); err != nil {
t.Fatal(err)
}
user := models.User{Account: "root", Role: "super_admin", SessionVersion: 2, SecurityVersion: 3}
if err := auth.SetPassword(&user, "OldPass123"); err != nil {
t.Fatal(err)
}
if _, err := engine.Insert(&user); err != nil {
t.Fatal(err)
}
root := t.TempDir()
vault, err := externalemail.NewVault(root)
if err != nil {
t.Fatal(err)
}
email, err := externalemail.NewRepository(engine, vault)
if err != nil {
t.Fatal(err)
}
codes, err := credentials.NewService(engine)
if err != nil {
t.Fatal(err)
}
authenticator, err := totp.NewService(engine, root)
if err != nil {
t.Fatal(err)
}
store, err := verification.NewStore(20)
if err != nil {
t.Fatal(err)
}
var delivered string
verify, err := verification.NewService(store, func(_ verification.Challenge, code string) error { delivered = code; return nil }, nil)
if err != nil {
t.Fatal(err)
}
return NewVerificationService(engine, email, codes, authenticator, verify, nil), user, &delivered
}
func addRecovery(t *testing.T, s *VerificationService, user models.User) string {
t.Helper()
code := "ABCD-EFGH-IJKL-MNOP"
hash, err := password.Hash(code)
if err != nil {
t.Fatal(err)
}
if _, err := s.engine.Insert(&models.RecoveryCode{UserID: user.ID, CodeHash: hash}); err != nil {
t.Fatal(err)
}
return code
}
func TestVerifiedResetWithoutEmailOverProtocol(t *testing.T) {
s, user, delivered := verificationFixture(t)
if _, err := s.Begin(); err == nil {
t.Fatal("unconfigured account allowed")
}
code := addRecovery(t, s, user)
server, client := net.Pipe()
done := make(chan struct{})
go func() {
defer close(done)
defer server.Close()
handleResetConnection(server, server.SetDeadline, s.Begin, NewSessionGuard(time.Minute))
}()
defer client.Close()
steps := 0
err := SendVerifiedReset(context.Background(), client, func(string) (string, error) {
steps++
if steps == 1 {
return "1", nil
}
return code, nil
}, func() (string, error) {
if steps != 2 {
t.Error("password asked before verification")
}
return "NewPass123", nil
})
if err != nil {
t.Fatal(err)
}
<-done
var updated models.User
if _, err := s.engine.ID(user.ID).Get(&updated); err != nil {
t.Fatal(err)
}
if !password.Verify(updated.Password, "NewPass123") || updated.SessionVersion != 3 || updated.SecurityVersion != 4 {
t.Fatal("reset did not commit")
}
if ready, err := s.codes.HasValidRecoveryCode(user.ID); err != nil || ready {
t.Fatal("recovery code not consumed")
}
if *delivered != "" {
t.Fatal("mail sent without selection")
}
}
func TestVerifiedResetRejectsRevokedCredentialAndExpiredGrant(t *testing.T) {
for _, change := range []string{"code", "account", "expired"} {
t.Run(change, func(t *testing.T) {
s, user, _ := verificationFixture(t)
code := addRecovery(t, s, user)
flow, err := s.Begin()
if err != nil {
t.Fatal(err)
}
defer flow.Close()
if err := flow.Start("recovery"); err != nil {
t.Fatal(err)
}
if err := flow.Reset("NewPass123"); err == nil {
t.Fatal("unverified reset accepted")
}
if err := flow.Verify(code); err != nil {
t.Fatal(err)
}
switch change {
case "code":
if err := s.codes.RevokeRecoveryCodes(user.ID); err != nil {
t.Fatal(err)
}
case "account":
if _, err := s.engine.ID(user.ID).Cols("security_version").Update(&models.User{SecurityVersion: 8}); err != nil {
t.Fatal(err)
}
case "expired":
flow.(*verifiedReset).expires = time.Now().Add(-time.Second)
}
if err := flow.Reset("NewPass123"); err == nil {
t.Fatal("stale grant accepted")
}
var unchanged models.User
if _, err := s.engine.ID(user.ID).Get(&unchanged); err != nil {
t.Fatal(err)
}
if unchanged.Password != user.Password {
t.Fatal("rejected request changed password")
}
})
}
}
func TestVerifiedResetEmailIsExplicitAndBound(t *testing.T) {
s, user, delivered := verificationFixture(t)
item, err := s.email.Bind(externalemail.BindRequest{UserID: user.ID, Email: "root@example.com", Type: models.ExternalEmailTypeBackup})
if err != nil {
t.Fatal(err)
}
if _, err := s.engine.ID(item.ID).Cols("status").Update(&models.ExternalEmail{Status: models.ExternalEmailStatusVerified}); err != nil {
t.Fatal(err)
}
flow, err := s.Begin()
if err != nil {
t.Fatal(err)
}
defer flow.Close()
if *delivered != "" {
t.Fatal("mail sent before selection")
}
if err := flow.Start(flow.Methods()[0].ID); err != nil {
t.Fatal(err)
}
if *delivered == "" {
t.Fatal("mail not sent")
}
if err := flow.Verify(*delivered); err != nil {
t.Fatal(err)
}
if _, err := s.engine.ID(item.ID).Cols("status").Update(&models.ExternalEmail{Status: models.ExternalEmailStatusDisabled}); err != nil {
t.Fatal(err)
}
if err := flow.Reset("NewPass123"); err == nil {
t.Fatal("disabled email accepted")
}
}
func TestVerifiedResetTOTPAndReplay(t *testing.T) {
s, user, _ := verificationFixture(t)
enrollment, err := s.totp.BeginEnrollment(user.ID, user.Account)
if err != nil {
t.Fatal(err)
}
secret, err := base32.StdEncoding.WithPadding(base32.NoPadding).DecodeString(enrollment.Secret)
if err != nil {
t.Fatal(err)
}
makeCode := func(step int64) string {
counter := make([]byte, 8)
binary.BigEndian.PutUint64(counter, uint64(step))
mac := hmac.New(sha256.New, secret)
_, _ = mac.Write(counter)
digest := mac.Sum(nil)
offset := digest[len(digest)-1] & 15
return fmt.Sprintf("%06d", (binary.BigEndian.Uint32(digest[offset:offset+4])&0x7fffffff)%1000000)
}
step := time.Now().Unix() / 30
if err := s.totp.ConfirmEnrollment(user.ID, enrollment.ID, makeCode(step-1)); err != nil {
t.Fatal(err)
}
flow, err := s.Begin()
if err != nil {
t.Fatal(err)
}
defer flow.Close()
if err := flow.Start("totp"); err != nil {
t.Fatal(err)
}
if err := flow.Verify(makeCode(step)); err != nil {
t.Fatal(err)
}
if err := s.totp.Verify(user.ID, makeCode(step)); err == nil {
t.Fatal("TOTP replay accepted")
}
if err := flow.Reset("NewPass123"); err != nil {
t.Fatal(err)
}
}
func TestVerifiedResetLimitsAcrossConnections(t *testing.T) {
s, user, _ := verificationFixture(t)
code := addRecovery(t, s, user)
for i := 0; i < 5; i++ {
flow, err := s.Begin()
if err != nil {
t.Fatal(err)
}
if err := flow.Start("recovery"); err != nil {
t.Fatal(err)
}
if err := flow.Verify("WRONG-CODE-123456"); err == nil {
t.Fatal("wrong code accepted")
}
flow.Close()
}
flow, err := s.Begin()
if err != nil {
t.Fatal(err)
}
defer flow.Close()
if err := flow.Start("recovery"); err != nil {
t.Fatal(err)
}
if err := flow.Verify(code); err == nil {
t.Fatal("new connection bypassed limit")
}
}
func TestProtocolRejectsSkippedVerification(t *testing.T) {
server, client := net.Pipe()
defer client.Close()
done := make(chan struct{})
go func() {
defer close(done)
defer server.Close()
handleResetConnection(server, server.SetDeadline, testResetHandler(func(string) error { t.Error("reset bypassed verification"); return nil }), NewSessionGuard(time.Minute))
}()
challenge, err := DecodeResponse(client)
if err != nil {
t.Fatal(err)
}
if err := json.NewEncoder(client).Encode(Request{Version: ProtocolVersion, Nonce: challenge.Nonce, Action: "reset", NewPassword: "NewPass123"}); err != nil {
t.Fatal(err)
}
result, err := DecodeResponse(client)
if err != nil || result.OK {
t.Fatal("skipped verification accepted")
}
<-done
}
@@ -228,6 +228,8 @@ func CodeMessage(purpose Purpose, code string) (string, string) {
purposeText = "完成密码恢复验证"
case PurposePasswordChange:
purposeText = "完成修改密码安全验证"
case PurposeAdminLocalReset:
purposeText = "完成超级管理员本机密码重置验证"
case PurposeExternalEmailBind:
purposeText = "完成外部邮箱绑定验证"
case PurposeExternalEmailChange:
+2 -1
View File
@@ -35,6 +35,7 @@ const (
PurposeLogin Purpose = "login"
PurposePasswordRecover Purpose = "password_recover"
PurposePasswordChange Purpose = "password_change"
PurposeAdminLocalReset Purpose = "admin_local_reset"
PurposeExternalEmailBind Purpose = "external_email_bind"
PurposeExternalEmailChange Purpose = "external_email_change"
)
@@ -191,7 +192,7 @@ func (s *Store) issue(request IssueRequest, delivery Delivery, onVerified func()
// IsSupportedPurpose 保证验证码只能用于已确认的业务流程。
func IsSupportedPurpose(purpose Purpose) bool {
switch purpose {
case PurposeLogin, PurposePasswordRecover, PurposePasswordChange, PurposeExternalEmailBind, PurposeExternalEmailChange:
case PurposeLogin, PurposePasswordRecover, PurposePasswordChange, PurposeExternalEmailBind, PurposeExternalEmailChange, PurposeAdminLocalReset:
return true
default:
return false