保存本机只读核查入口并开始全量失败修复

本机协议及菜单已实现,Linux专项通过;全量存在环境缺失和SQLite截止时间失败,尚未通过生产验收。
This commit is contained in:
xuans committed 2026-10-03 18:23:48 +08:00
1 parent c9045a084f
commit 978f023a7f
23 files changed
+1386 -20

No files matched your search

+16 -9
View File
@@ -9,14 +9,15 @@ import (
)
type Client struct {
conn net.Conn
reader *bufio.Reader
nonce string
methods []Method
stage int
stop func() bool
mu sync.Mutex
once sync.Once
conn net.Conn
reader *bufio.Reader
nonce string
methods []Method
recoveryAvailable bool
stage int
stop func() bool
mu sync.Mutex
once sync.Once
}
// Begin 只接受已通过 Dial 校验身份的连接;调用过程不会通过参数或文件传递密码。
@@ -36,12 +37,13 @@ func Begin(ctx context.Context, conn net.Conn) (*Client, error) {
client.stop = context.AfterFunc(ctx, func() { _ = conn.Close() })
var response Response
if err := readFrame(client.reader, &response); err != nil || !validChallenge(response) ||
len(response.Methods) == 0 || len(response.Methods) > 8 {
len(response.Methods) == 0 || len(response.Methods) > 8 || response.RecoveryPage != nil || response.Inspection != nil {
_ = client.Close()
return nil, ErrProtocol
}
client.nonce = response.Nonce
client.methods = response.Methods
client.recoveryAvailable = response.RecoveryAvailable
return client, nil
}
@@ -75,6 +77,11 @@ func (c *Client) exchange(request Request, stage int) error {
_ = c.Close()
return ErrProtocol
}
if response.RecoveryAvailable || response.RecoveryPage != nil || response.Inspection != nil {
c.stage = -1
_ = c.Close()
return ErrProtocol
}
if stage == 2 {
c.stage = -1
_ = c.Close()
+28 -11
View File
@@ -13,6 +13,8 @@ import (
"net"
"sync"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
)
const (
@@ -38,20 +40,25 @@ type Method struct {
}
type Request struct {
Version int `json:"version"`
Nonce string `json:"nonce"`
Action string `json:"action"`
Method string `json:"method,omitempty"`
Code string `json:"code,omitempty"`
Password string `json:"password,omitempty"`
Version int `json:"version"`
Nonce string `json:"nonce"`
Action string `json:"action"`
Method string `json:"method,omitempty"`
Code string `json:"code,omitempty"`
Password string `json:"password,omitempty"`
Cursor string `json:"cursor,omitempty"`
TransactionID string `json:"transaction_id,omitempty"`
}
type Response struct {
Version int `json:"version"`
OK bool `json:"ok"`
Code string `json:"code"`
Nonce string `json:"nonce,omitempty"`
Methods []Method `json:"methods,omitempty"`
Version int `json:"version"`
OK bool `json:"ok"`
Code string `json:"code"`
Nonce string `json:"nonce,omitempty"`
Methods []Method `json:"methods,omitempty"`
RecoveryAvailable bool `json:"recovery_available,omitempty"`
RecoveryPage *deployment.PendingRecoveryPage `json:"recovery_page,omitempty"`
Inspection *deployment.RecoveryInspection `json:"inspection,omitempty"`
}
// Session 由主服务创建,身份验证及密码持久化仍由主服务负责。
@@ -214,6 +221,8 @@ func (s *Server) handle(parent context.Context, conn net.Conn, factory Factory)
return
}
reader := bufio.NewReaderSize(conn, MaxFrameSize+1)
recovery, hasRecovery := session.(RecoverySession)
hasRecovery = hasRecovery && recovery.RecoveryAvailable()
for index, action := range []string{"select", "verify", "reset"} {
nonce, err := newNonce()
if err != nil {
@@ -222,12 +231,17 @@ func (s *Server) handle(parent context.Context, conn net.Conn, factory Factory)
response := Response{Version: Version, OK: true, Code: "CHALLENGE", Nonce: nonce}
if index == 0 {
response.Methods = methods
response.RecoveryAvailable = hasRecovery
}
if writeFrame(conn, response) != nil {
return
}
var request Request
err = readFrame(reader, &request)
if err == nil && index == 0 && hasRecovery && validRecoveryRequest(request, nonce) {
s.handleRecovery(ctx, conn, reader, peer, recovery, request)
return
}
if err != nil || ctx.Err() != nil || !validRequest(request, nonce, action) {
s.failed(peer.Identity)
_ = writeFrame(conn, Response{Version: Version, Code: "INVALID_REQUEST"})
@@ -261,6 +275,9 @@ func (s *Server) handle(parent context.Context, conn net.Conn, factory Factory)
}
func validRequest(request Request, nonce, action string) bool {
if request.Cursor != "" || request.TransactionID != "" {
return false
}
if request.Version != Version || request.Action != action ||
subtle.ConstantTimeCompare([]byte(request.Nonce), []byte(nonce)) != 1 {
return false
+104
View File
@@ -0,0 +1,104 @@
package localreset
import (
"context"
"crypto/subtle"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
)
const MaxRecoveryRequests = 32
// RecoverySession 仅供受保护的本机连接使用,与邮箱密码重置阶段互斥。
type RecoverySession interface {
RecoveryAvailable() bool
ListRecoveries(context.Context, string) (deployment.PendingRecoveryPage, error)
InspectRecovery(context.Context, string) (deployment.RecoveryInspection, error)
}
func validRecoveryRequest(request Request, nonce string) bool {
if request.Version != Version || subtle.ConstantTimeCompare([]byte(request.Nonce), []byte(nonce)) != 1 ||
request.Method != "" || request.Code != "" || request.Password != "" {
return false
}
switch request.Action {
case "recovery_list":
return request.TransactionID == "" && (request.Cursor == "" || validRecoveryID(request.Cursor))
case "recovery_inspect":
return request.Cursor == "" && validRecoveryID(request.TransactionID)
}
return false
}
func validRecoveryID(value string) bool {
if len(value) == 0 || len(value) > 160 || value == "." || value == ".." {
return false
}
for _, c := range value {
if (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && (c < '0' || c > '9') && c != '-' && c != '.' && c != '_' {
return false
}
}
return true
}
func (c *Client) RecoveryAvailable() bool { return c.recoveryAvailable }
func (c *Client) ListRecoveries(cursor string) (deployment.PendingRecoveryPage, error) {
response, err := c.recoveryExchange(Request{Action: "recovery_list", Cursor: cursor})
if err != nil {
return deployment.PendingRecoveryPage{}, err
}
return *response.RecoveryPage, nil
}
func (c *Client) InspectRecovery(id string) (deployment.RecoveryInspection, error) {
response, err := c.recoveryExchange(Request{Action: "recovery_inspect", TransactionID: id})
if err != nil {
return deployment.RecoveryInspection{}, err
}
return *response.Inspection, nil
}
func (c *Client) recoveryExchange(request Request) (Response, error) {
c.mu.Lock()
defer c.mu.Unlock()
fail := func() (Response, error) {
c.stage = -1
_ = c.Close()
return Response{}, ErrProtocol
}
if !c.recoveryAvailable || (c.stage != 0 && c.stage != 3) {
return fail()
}
request.Version, request.Nonce = Version, c.nonce
if !validRecoveryRequest(request, c.nonce) || writeFrame(c.conn, request) != nil {
return fail()
}
var response Response
if readFrame(c.reader, &response) != nil || !validChallenge(response) || response.Nonce == c.nonce ||
len(response.Methods) != 0 || response.RecoveryAvailable {
return fail()
}
if request.Action == "recovery_list" {
if response.RecoveryPage == nil || response.Inspection != nil || len(response.RecoveryPage.Items) > deployment.RecoveryPageSize {
return fail()
}
previous := request.Cursor
for _, item := range response.RecoveryPage.Items {
if !validRecoveryID(item.ID) || item.ID <= previous {
return fail()
}
previous = item.ID
}
if cursor := response.RecoveryPage.NextCursor; cursor != "" &&
(len(response.RecoveryPage.Items) != deployment.RecoveryPageSize || cursor != previous) {
return fail()
}
} else if response.Inspection == nil || response.RecoveryPage != nil || response.Inspection.TransactionID != request.TransactionID ||
len(response.Inspection.Files) != 9 || len(response.Inspection.Locks) != 3 || response.Inspection.ObservedAt.IsZero() {
return fail()
}
c.nonce, c.stage = response.Nonce, 3
return response, nil
}
@@ -0,0 +1,116 @@
package localreset
import (
"bufio"
"net"
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
)
func TestRecoveryClientRejectsMalformedResponses(t *testing.T) {
for _, scenario := range []string{"nonce", "methods", "capability", "missing-page", "large-page", "duplicate-id", "backward-cursor", "mixed-result", "wrong-id", "partial-files", "partial-locks", "missing-time"} {
t.Run(scenario, func(t *testing.T) {
serverConn, conn := net.Pipe()
defer conn.Close()
defer serverConn.Close()
_ = serverConn.SetDeadline(time.Now().Add(time.Second))
done := make(chan struct{})
go func() {
defer close(done)
defer serverConn.Close()
nonce := strings.Repeat("a", 64)
if writeFrame(serverConn, Response{Version: Version, OK: true, Code: "CHALLENGE", Nonce: nonce,
Methods: []Method{{ID: "email"}}, RecoveryAvailable: true}) != nil {
return
}
var request Request
if readFrame(bufio.NewReaderSize(serverConn, MaxFrameSize+1), &request) != nil {
return
}
response := Response{Version: Version, OK: true, Code: "CHALLENGE", Nonce: strings.Repeat("b", 64)}
if request.Action == "recovery_list" {
response.RecoveryPage = &deployment.PendingRecoveryPage{Items: []deployment.PendingRecovery{{ID: "tx-1"}}}
} else {
response.Inspection = &deployment.RecoveryInspection{TransactionID: "tx-1", ObservedAt: time.Now(),
Files: make([]deployment.RecoveryFileObservation, 9), Locks: make([]deployment.RecoveryLockObservation, 3)}
}
switch scenario {
case "nonce":
response.Nonce = nonce
case "methods":
response.Methods = []Method{{ID: "email"}}
case "capability":
response.RecoveryAvailable = true
case "missing-page":
response.RecoveryPage = nil
case "large-page":
response.RecoveryPage.Items = make([]deployment.PendingRecovery, 6)
case "duplicate-id":
response.RecoveryPage.Items = append(response.RecoveryPage.Items, response.RecoveryPage.Items[0])
case "backward-cursor":
response.RecoveryPage.NextCursor = "tx-0"
case "mixed-result":
response.Inspection = &deployment.RecoveryInspection{TransactionID: "tx-1"}
case "wrong-id":
response.Inspection.TransactionID = "tx-2"
case "partial-files":
response.Inspection.Files = response.Inspection.Files[:8]
case "partial-locks":
response.Inspection.Locks = response.Inspection.Locks[:2]
case "missing-time":
response.Inspection.ObservedAt = time.Time{}
}
_ = writeFrame(serverConn, response)
}()
client, err := Begin(t.Context(), conn)
if err != nil {
t.Fatal(err)
}
defer client.Close()
switch scenario {
case "wrong-id", "partial-files", "partial-locks", "missing-time":
result, err := client.InspectRecovery("tx-1")
if err == nil || result.TransactionID != "" {
t.Fatal("malformed observation accepted")
}
default:
page, err := client.ListRecoveries("")
if err == nil || len(page.Items) != 0 {
t.Fatal("malformed list accepted")
}
}
<-done
})
}
}
func TestRecoveryProtocolCannotEnterAfterResetSelection(t *testing.T) {
session := &recoveryTestSession{}
_, conn, done := recoveryConnection(t, session)
reader := bufio.NewReaderSize(conn, MaxFrameSize+1)
var response Response
if err := readFrame(reader, &response); err != nil {
t.Fatal(err)
}
if err := writeFrame(conn, Request{Version: Version, Nonce: response.Nonce, Action: "select", Method: "recovery"}); err != nil {
t.Fatal(err)
}
response = Response{}
if err := readFrame(reader, &response); err != nil {
t.Fatal(err)
}
if err := writeFrame(conn, Request{Version: Version, Nonce: response.Nonce, Action: "recovery_list"}); err != nil {
t.Fatal(err)
}
response = Response{}
if err := readFrame(reader, &response); err != nil || response.OK {
t.Fatal("reset switched into inspection")
}
<-done
if session.lists.Load() != 0 || session.inspects.Load() != 0 || session.resets.Load() != 0 {
t.Fatal("invalid cross-flow reached service")
}
}
@@ -0,0 +1,50 @@
package localreset
import (
"bufio"
"context"
"errors"
"io"
"net"
)
func (s *Server) handleRecovery(ctx context.Context, conn net.Conn, reader *bufio.Reader, peer Peer, session RecoverySession, request Request) {
for count := 0; count < MaxRecoveryRequests; count++ {
if ctx.Err() != nil {
return
}
nonce, err := newNonce()
if err != nil {
return
}
response := Response{Version: Version, OK: true, Code: "CHALLENGE", Nonce: nonce}
switch request.Action {
case "recovery_list":
page, readErr := session.ListRecoveries(ctx, request.Cursor)
err, response.RecoveryPage = readErr, &page
case "recovery_inspect":
inspection, readErr := session.InspectRecovery(ctx, request.TransactionID)
err, response.Inspection = readErr, &inspection
default:
err = ErrProtocol
}
if err != nil || ctx.Err() != nil {
s.failed(peer.Identity)
_ = writeFrame(conn, Response{Version: Version, Code: "REJECTED"})
return
}
if writeFrame(conn, response) != nil {
return
}
request = Request{}
if _, err := reader.Peek(1); errors.Is(err, io.EOF) {
return
}
if readFrame(reader, &request) != nil || !validRecoveryRequest(request, nonce) {
s.failed(peer.Identity)
_ = writeFrame(conn, Response{Version: Version, Code: "INVALID_REQUEST"})
return
}
}
_ = writeFrame(conn, Response{Version: Version, Code: "LIMIT_REACHED"})
}
@@ -0,0 +1,202 @@
package localreset
import (
"bufio"
"context"
"errors"
"net"
"strings"
"sync/atomic"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
)
type recoveryTestSession struct {
testSession
lists atomic.Int32
inspects atomic.Int32
fail bool
oversized bool
}
func (*recoveryTestSession) RecoveryAvailable() bool { return true }
func (s *recoveryTestSession) ListRecoveries(context.Context, string) (deployment.PendingRecoveryPage, error) {
s.lists.Add(1)
return deployment.PendingRecoveryPage{Items: []deployment.PendingRecovery{{ID: "tx-1", ServerID: "s1"}}}, nil
}
func (s *recoveryTestSession) InspectRecovery(_ context.Context, id string) (deployment.RecoveryInspection, error) {
s.inspects.Add(1)
result := deployment.RecoveryInspection{TransactionID: id, ServerID: "s1", ObservedAt: time.Now(),
Files: make([]deployment.RecoveryFileObservation, 9), Locks: make([]deployment.RecoveryLockObservation, 3)}
if s.fail {
return result, errors.New("secret-error")
}
if s.oversized {
result.Files[0].Path = strings.Repeat("x", MaxFrameSize)
}
return result, nil
}
func recoveryConnection(t *testing.T, session *recoveryTestSession) (*Server, net.Conn, <-chan struct{}) {
t.Helper()
serverConn, clientConn := net.Pipe()
server := newServer(nil, func(net.Conn) (Peer, error) { return Peer{Identity: "test"}, nil }, nil)
server.timeout = 5 * time.Second
done := make(chan struct{})
ctx, cancel := context.WithCancel(t.Context())
go func() {
defer close(done)
defer serverConn.Close()
server.handle(ctx, serverConn, func(context.Context, Peer) (Session, error) { return session, nil })
}()
t.Cleanup(func() {
cancel()
_ = clientConn.Close()
_ = serverConn.Close()
select {
case <-done:
case <-time.After(time.Second):
t.Error("recovery session did not exit")
}
})
return server, clientConn, done
}
func TestRecoveryProtocolRoundTrip(t *testing.T) {
session := &recoveryTestSession{}
server, conn, done := recoveryConnection(t, session)
client, err := Begin(t.Context(), conn)
if err != nil || !client.RecoveryAvailable() {
t.Fatalf("begin: %v", err)
}
page, err := client.ListRecoveries("")
if err != nil || len(page.Items) != 1 {
t.Fatal(err)
}
result, err := client.InspectRecovery(page.Items[0].ID)
if err != nil || result.HistoricalEvidence || result.TransactionID != "tx-1" {
t.Fatalf("inspection: %+v, %v", result, err)
}
_ = client.Close()
<-done
if session.resets.Load() != 0 || session.selected.Load() != 0 || session.verified.Load() != 0 ||
session.closed.Load() != 1 || session.lists.Load() != 1 || session.inspects.Load() != 1 || len(server.failures) != 0 {
t.Fatal("read-only flow mutated reset state, leaked session, or penalized clean close")
}
}
func TestRecoveryProtocolRejectsReplayAndCrossFlow(t *testing.T) {
for _, scenario := range []string{"replay", "select", "verify", "reset", "mixed", "bad-id"} {
t.Run(scenario, func(t *testing.T) {
session := &recoveryTestSession{}
_, conn, done := recoveryConnection(t, session)
reader := bufio.NewReaderSize(conn, MaxFrameSize+1)
var response Response
if err := readFrame(reader, &response); err != nil {
t.Fatal(err)
}
oldNonce := response.Nonce
if err := writeFrame(conn, Request{Version: Version, Nonce: oldNonce, Action: "recovery_list"}); err != nil {
t.Fatal(err)
}
if err := readFrame(reader, &response); err != nil {
t.Fatal(err)
}
request := Request{Version: Version, Nonce: response.Nonce, Action: "recovery_inspect", TransactionID: "tx-1"}
switch scenario {
case "replay":
request.Nonce = oldNonce
case "select":
request = Request{Version: Version, Nonce: response.Nonce, Action: "select", Method: "recovery"}
case "verify":
request = Request{Version: Version, Nonce: response.Nonce, Action: "verify", Code: "test-code"}
case "reset":
request = Request{Version: Version, Nonce: response.Nonce, Action: "reset", Password: "Example123!"}
case "mixed":
request.Password = "secret-password"
case "bad-id":
request.TransactionID = "../bad"
}
if err := writeFrame(conn, request); err != nil {
t.Fatal(err)
}
response = Response{}
if err := readFrame(reader, &response); err != nil || response.OK || response.Inspection != nil {
t.Fatalf("accepted: %+v %v", response, err)
}
<-done
if session.inspects.Load() != 0 || session.resets.Load() != 0 || session.selected.Load() != 0 || session.verified.Load() != 0 {
t.Fatal("invalid request reached business operation")
}
})
}
}
func TestRecoveryClientAndResetMutuallyExclusive(t *testing.T) {
for _, first := range []string{"reset", "recovery"} {
t.Run(first, func(t *testing.T) {
session := &recoveryTestSession{}
_, conn, _ := recoveryConnection(t, session)
client, err := Begin(t.Context(), conn)
if err != nil {
t.Fatal(err)
}
defer client.Close()
if first == "reset" {
if err := client.Select("recovery"); err != nil {
t.Fatal(err)
}
if _, err := client.ListRecoveries(""); err == nil {
t.Fatal("cross-flow accepted")
}
} else {
if _, err := client.ListRecoveries(""); err != nil {
t.Fatal(err)
}
if err := client.Select("recovery"); err == nil {
t.Fatal("cross-flow accepted")
}
}
})
}
}
func TestRecoveryProtocolFailureReturnsNoPartialData(t *testing.T) {
for _, oversized := range []bool{false, true} {
session := &recoveryTestSession{fail: !oversized, oversized: oversized}
_, conn, _ := recoveryConnection(t, session)
client, err := Begin(t.Context(), conn)
if err != nil {
t.Fatal(err)
}
result, err := client.InspectRecovery("tx-1")
if err == nil || result.TransactionID != "" || len(result.Files) != 0 || strings.Contains(err.Error(), "secret") {
t.Fatal("failure leaked partial data")
}
_ = client.Close()
}
}
func TestRecoveryProtocolRequestLimit(t *testing.T) {
session := &recoveryTestSession{}
_, conn, done := recoveryConnection(t, session)
client, err := Begin(t.Context(), conn)
if err != nil {
t.Fatal(err)
}
defer client.Close()
for i := 0; i < MaxRecoveryRequests; i++ {
if _, err := client.ListRecoveries(""); err != nil {
t.Fatal(err)
}
}
if _, err := client.ListRecoveries(""); err == nil {
t.Fatal("request limit ignored")
}
<-done
if session.lists.Load() != MaxRecoveryRequests {
t.Fatal("extra list reached service")
}
}