保存本机只读核查入口并开始全量失败修复
本机协议及菜单已实现,Linux专项通过;全量存在环境缺失和SQLite截止时间失败,尚未通过生产验收。
This commit is contained in:
1 parent
c9045a084f
commit
978f023a7f
23 files changed
+1386
-20
No files matched your search
@@ -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()
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user