完善部署现场只读核查并补充Linux安全回归和进度

This commit is contained in:
xuans committed 2026-10-03 17:36:19 +08:00
1 parent 80b6c0c707
commit 44c88fe9b3
9 files changed
+375 -8

No files matched your search

@@ -44,6 +44,8 @@ type RecoveryLockObservation struct {
// InspectPending 只读取待恢复记录与远端文件,绝不运行命令、建立锁或修改事务。
// 缺失的历史证据保持缺失,当前观测摘要不能补写为当时的恢复证据。
func (s *Service) InspectPending(ctx context.Context, id string, resolve func(context.Context, string) (Server, error)) (RecoveryInspection, error) {
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
if err := ctx.Err(); err != nil {
return RecoveryInspection{}, err
}
@@ -55,7 +57,7 @@ func (s *Service) InspectPending(ctx context.Context, id string, resolve func(co
}
records, err := s.journal.ListPendingDeploymentTransactions(ctx)
if err != nil {
return RecoveryInspection{}, ErrRecoveryInspectionUnavailable
return RecoveryInspection{}, inspectionError(ctx, ErrRecoveryInspectionUnavailable)
}
var record *TransactionRecord
for i := range records {
@@ -74,7 +76,7 @@ func (s *Service) InspectPending(ctx context.Context, id string, resolve func(co
}
server, err := resolve(ctx, record.ServerID)
if err != nil {
return RecoveryInspection{}, ErrRecoveryInspectionUnavailable
return RecoveryInspection{}, inspectionError(ctx, ErrRecoveryInspectionUnavailable)
}
server = server.Normalize()
if server.ID != record.ServerID || server.Validate() != nil {
@@ -88,7 +90,7 @@ func (s *Service) InspectPending(ctx context.Context, id string, resolve func(co
}
client, err := s.factory.Connect(ctx, server)
if err != nil {
return RecoveryInspection{}, ErrRecoveryInspectionUnavailable
return RecoveryInspection{}, inspectionError(ctx, ErrRecoveryInspectionUnavailable)
}
defer client.Close()
reader, ok := client.(EvidenceClient)
@@ -121,13 +123,13 @@ func (s *Service) InspectPending(ctx context.Context, id string, resolve func(co
}
exists, err := client.Exists(ctx, item.path)
if err != nil {
return RecoveryInspection{}, ErrRecoveryInspectionRead
return RecoveryInspection{}, inspectionError(ctx, ErrRecoveryInspectionRead)
}
observation := RecoveryFileObservation{Path: item.path, Kind: item.kind, Exists: exists, Comparison: "missing"}
if exists {
digest, err := reader.FileDigest(ctx, item.path)
if err != nil || !validDigest(digest) {
return RecoveryInspection{}, ErrRecoveryInspectionRead
return RecoveryInspection{}, inspectionError(ctx, ErrRecoveryInspectionRead)
}
observation.Digest, observation.Comparison = digest, "unrecorded"
if validDigest(item.expected) {
@@ -142,12 +144,12 @@ func (s *Service) InspectPending(ctx context.Context, id string, resolve func(co
lock := RecoveryLockObservation{Path: target + ".scert-lock", Ownership: "missing"}
lock.Exists, err = client.Exists(ctx, lock.Path)
if err != nil {
return RecoveryInspection{}, ErrRecoveryInspectionRead
return RecoveryInspection{}, inspectionError(ctx, ErrRecoveryInspectionRead)
}
if lock.Exists {
owner, err := reader.ReadLockOwner(ctx, lock.Path)
if err != nil {
return RecoveryInspection{}, ErrRecoveryInspectionRead
return RecoveryInspection{}, inspectionError(ctx, ErrRecoveryInspectionRead)
}
lock.Ownership = "unproven"
if record.Evidence != nil && validDigest(owner) {
@@ -166,6 +168,13 @@ func (s *Service) InspectPending(ctx context.Context, id string, resolve func(co
return result, nil
}
func inspectionError(ctx context.Context, fallback error) error {
if err := ctx.Err(); err != nil {
return err
}
return fallback
}
func validInspectionID(id string) bool {
if len(id) == 0 || len(id) > 160 {
return false
@@ -0,0 +1,90 @@
package deployment
import (
"context"
"errors"
"reflect"
"strings"
"testing"
"time"
)
type inspectionCancelClient struct {
*inspectionClient
cancel context.CancelFunc
stage string
}
func (c *inspectionCancelClient) Exists(ctx context.Context, path string) (bool, error) {
if c.stage == "exists" || (c.stage == "lock-exists" && strings.HasSuffix(path, ".scert-lock")) {
c.cancel()
return false, errors.New("sensitive-read-error")
}
return c.memoryClient.Exists(ctx, path)
}
func (c *inspectionCancelClient) FileDigest(ctx context.Context, path string) (string, error) {
if c.stage == "digest" {
c.cancel()
return "", errors.New("sensitive-read-error")
}
return c.memoryClient.FileDigest(ctx, path)
}
func (c *inspectionCancelClient) ReadLockOwner(ctx context.Context, path string) (string, error) {
if c.stage == "owner" {
c.cancel()
return "", errors.New("sensitive-read-error")
}
return c.memoryClient.ReadLockOwner(ctx, path)
}
func TestRecoveryInspectionCancellationBoundaries(t *testing.T) {
for _, stage := range []string{"resolve", "exists", "digest", "lock-exists", "owner"} {
t.Run(stage, func(t *testing.T) {
server, memory, record := recoveryPreflightFixture()
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
client := &inspectionCancelClient{inspectionClient: &inspectionClient{memoryClient: memory}, cancel: cancel, stage: stage}
journal := &memoryTransactionJournal{pending: []TransactionRecord{record}}
factory := &inspectionFactory{client: client}
service := NewServiceWithJournal(factory, journal)
result, err := service.InspectPending(ctx, record.ID, func(ctx context.Context, id string) (Server, error) {
deadline, ok := ctx.Deadline()
if !ok || time.Until(deadline) > 30*time.Second {
t.Fatal("inspection lacks bounded deadline")
}
if stage == "resolve" {
cancel()
return Server{}, errors.New("sensitive-resolve-error")
}
return server, nil
})
if !errors.Is(err, context.Canceled) || !reflect.DeepEqual(result, RecoveryInspection{}) {
t.Fatalf("cancellation lost: %+v %v", result, err)
}
if client.closed != factory.calls || client.mutations != 0 || len(journal.updated) != 0 || len(journal.finished) != 0 {
t.Fatal("cancellation changed state or leaked client")
}
})
}
}
func TestRecoveryInspectionPreservesEarlierDeadline(t *testing.T) {
server, memory, record := recoveryPreflightFixture()
ctx, cancel := context.WithTimeout(t.Context(), time.Second)
defer cancel()
deadline, _ := ctx.Deadline()
client := &inspectionClient{memoryClient: memory}
service := NewServiceWithJournal(fixedClientFactory{client}, &memoryTransactionJournal{pending: []TransactionRecord{record}})
_, err := service.InspectPending(ctx, record.ID, func(ctx context.Context, id string) (Server, error) {
actual, ok := ctx.Deadline()
if !ok || !actual.Equal(deadline) {
t.Fatal("caller deadline extended")
}
return server, nil
})
if err != nil {
t.Fatal(err)
}
}
@@ -0,0 +1,154 @@
//go:build linux
package deployment
import (
"context"
"errors"
"io/fs"
"os"
"path/filepath"
"reflect"
"strings"
"testing"
"time"
"golang.org/x/crypto/ssh"
)
func TestRecoveryInspectionOverPasswordSFTP(t *testing.T) {
signer := newTestECDSAHostSigner(t)
endpoint := startTestPasswordSSHServerWithHandler(t, func(password string) error {
if password != "test-password" {
return errors.New("invalid test password")
}
return nil
}, serveTestSFTP, signer)
for _, scenario := range []string{"trusted", "legacy", "target-symlink", "target-directory", "target-unreadable", "target-oversized", "owner-oversized", "owner-symlink", "lock-symlink"} {
t.Run(scenario, func(t *testing.T) {
root := t.TempDir()
server, memory, record := recoveryPreflightFixture(root)
model := testSSHServerModel(endpoint, "secret://ssh/inspection", ssh.FingerprintSHA256(signer.PublicKey()))
server.Address, server.Port, server.Username = model.Address, model.Port, model.Username
server.AuthMethod, server.PasswordRef, server.HostKeyFingerprint = model.AuthMethod, model.PasswordRef, model.HostKeyFingerprint
record.Evidence.Address, record.Evidence.Port, record.Evidence.HostKeyFingerprint = server.Address, server.Port, server.HostKeyFingerprint
for path, file := range memory.files {
if strings.HasSuffix(path, ".scert-lock") {
if err := os.MkdirAll(path, 0o700); err != nil {
t.Fatal(err)
}
continue
}
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(path, file.data, 0o600); err != nil {
t.Fatal(err)
}
}
target := record.Paths[0]
lock := record.LockPaths[0]
owner := lock + "/owner"
switch scenario {
case "legacy":
record.Evidence = nil
case "target-symlink", "owner-symlink", "lock-symlink":
name := target
if scenario == "owner-symlink" {
name = owner
}
if scenario == "lock-symlink" {
name = lock
}
if err := os.Rename(name, name+".original"); err != nil {
t.Fatal(err)
}
if err := os.Symlink(name+".original", name); err != nil {
t.Fatal(err)
}
case "target-directory":
if err := os.Rename(target, target+".original"); err != nil {
t.Fatal(err)
}
if err := os.Mkdir(target, 0o700); err != nil {
t.Fatal(err)
}
case "target-unreadable":
if os.Geteuid() == 0 {
t.Skip("requires unprivileged Linux test user")
}
if err := os.Chmod(target, 0); err != nil {
t.Fatal(err)
}
case "target-oversized":
if err := os.Truncate(target, 16*1024*1024+1); err != nil {
t.Fatal(err)
}
case "owner-oversized":
if err := os.Truncate(owner, 129); err != nil {
t.Fatal(err)
}
}
before := snapshotInspectionFiles(t, root)
journal := &memoryTransactionJournal{pending: []TransactionRecord{record}}
service := NewServiceWithJournal(SSHFactory{
Secrets: staticSecretReader{server.PasswordRef: {"password": "test-password"}},
Timeout: 5 * time.Second,
}, journal)
result, err := service.InspectPending(t.Context(), record.ID, func(context.Context, string) (Server, error) { return server, nil })
if scenario == "trusted" || scenario == "legacy" {
if err != nil || len(result.Files) != 9 || len(result.Locks) != 3 || result.HistoricalEvidence != (scenario == "trusted") {
t.Fatalf("inspection failed: %+v %v", result, err)
}
for _, file := range result.Files {
want := "match"
if scenario == "legacy" {
want = "unrecorded"
}
if file.Comparison != want {
t.Fatalf("unexpected observation: %+v", file)
}
}
} else if !errors.Is(err, ErrRecoveryInspectionRead) || !reflect.DeepEqual(result, RecoveryInspection{}) {
t.Fatalf("unsafe or unreadable file was accepted: %+v %v", result, err)
}
if !reflect.DeepEqual(before, snapshotInspectionFiles(t, root)) || len(journal.updated) != 0 || len(journal.finished) != 0 {
t.Fatal("read-only inspection changed files or journal")
}
})
}
}
func snapshotInspectionFiles(t *testing.T, root string) map[string]string {
t.Helper()
result := make(map[string]string)
err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, err error) error {
if err != nil {
return err
}
info, err := entry.Info()
if err != nil {
return err
}
value := info.Mode().String()
if info.Mode()&os.ModeSymlink != 0 {
target, err := os.Readlink(path)
if err != nil {
return err
}
value += target
} else if info.Mode().IsRegular() && info.Mode().Perm() != 0 {
data, err := os.ReadFile(path)
if err != nil {
return err
}
value += contentDigest(data)
}
result[path] = value
return nil
})
if err != nil {
t.Fatal(err)
}
return result
}
+24 -1
View File
@@ -300,6 +300,26 @@ func (c *sshClientAdapter) CreateOwnedLock(ctx context.Context, path, token stri
func (c *sshClientAdapter) ReadLockOwner(ctx context.Context, path string) (string, error) {
return sshOperation(ctx, c, func() (string, error) {
info, err := c.sftp.Lstat(path)
if errors.Is(err, os.ErrNotExist) {
return "", nil
}
if err != nil {
return "", err
}
if !info.IsDir() {
return "", ErrRecoveryInspectionRead
}
info, err = c.sftp.Lstat(path + "/owner")
if errors.Is(err, os.ErrNotExist) {
return "", nil
}
if err != nil {
return "", err
}
if !info.Mode().IsRegular() || info.Size() > 128 {
return "", ErrRecoveryInspectionRead
}
file, err := c.sftp.Open(path + "/owner")
if errors.Is(err, os.ErrNotExist) {
return "", nil
@@ -308,7 +328,10 @@ func (c *sshClientAdapter) ReadLockOwner(ctx context.Context, path string) (stri
return "", err
}
defer file.Close()
data, err := io.ReadAll(file)
data, err := io.ReadAll(io.LimitReader(file, 129))
if len(data) > 128 {
return "", ErrRecoveryInspectionRead
}
return strings.TrimSpace(string(data)), err
})
}