This commit is contained in:
1 parent
de8c298bd5
commit
67931eab5d
38 files changed
+1128
-135
No files matched your search
@@ -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
|
||||
}
|
||||
@@ -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 })
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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(¤t)
|
||||
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(¤t)
|
||||
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(¤t)
|
||||
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:
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in new issue
Block a user