保存本机重置业务初稿与通道权限测试检查点

This commit is contained in:
xuans committed 2026-09-21 00:39:47 +08:00
1 parent ec800fc4b6
commit 5c327e2b48
5 files changed
+597

No files matched your search

@@ -0,0 +1,164 @@
//go:build linux
package localreset
import (
"context"
"errors"
"net"
"os"
"path/filepath"
"testing"
"time"
)
func TestUnixSocketRoundTrip(t *testing.T) {
path := filepath.Join(t.TempDir(), "reset.sock")
server, err := Listen(path)
if err != nil {
t.Fatal(err)
}
defer server.Close()
info, err := os.Lstat(path)
if err != nil || info.Mode().Perm() != 0600 {
t.Fatalf("unsafe socket permissions: %v", err)
}
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
done := make(chan error, 1)
session := &testSession{}
go func() {
done <- server.Serve(ctx, func(context.Context, Peer) (Session, error) { return session, nil })
}()
conn, err := Dial(ctx, path, uint32(os.Geteuid()))
if err != nil {
t.Fatal(err)
}
client, err := Begin(ctx, conn)
if err != nil {
t.Fatal(err)
}
defer client.Close()
if err := client.Select("recovery"); err != nil {
t.Fatal(err)
}
if err := client.Verify("test-code"); err != nil {
t.Fatal(err)
}
if err := client.Reset("Example123!"); err != nil {
t.Fatal(err)
}
cancel()
if err := <-done; err != nil {
t.Fatal(err)
}
if session.resets.Load() != 1 || session.closed.Load() != 1 {
t.Fatal("session lifecycle incomplete")
}
if _, err := os.Lstat(path); !errors.Is(err, os.ErrNotExist) {
t.Fatal("owned socket not cleaned up")
}
}
func TestUnixRejectsUnsafeParent(t *testing.T) {
for _, mode := range []os.FileMode{0777, 0770} {
t.Run(mode.String(), func(t *testing.T) {
parent := t.TempDir()
if err := os.Chmod(parent, mode); err != nil {
t.Fatal(err)
}
if server, err := Listen(filepath.Join(parent, "reset.sock")); err == nil {
_ = server.Close()
t.Fatal("writable parent accepted")
}
})
}
parent := t.TempDir()
link := filepath.Join(parent, "link")
if err := os.Symlink(parent, link); err != nil {
t.Fatal(err)
}
if server, err := Listen(filepath.Join(link, "reset.sock")); err == nil {
_ = server.Close()
t.Fatal("symlink parent accepted")
}
}
func TestUnixRejectsUnsafePathsWithoutOverwriting(t *testing.T) {
parent := t.TempDir()
path := filepath.Join(parent, "reset.sock")
if err := os.WriteFile(path, []byte("preserve"), 0600); err != nil {
t.Fatal(err)
}
if server, err := Listen(path); err == nil {
_ = server.Close()
t.Fatal("regular file replaced")
}
data, err := os.ReadFile(path)
if err != nil || string(data) != "preserve" {
t.Fatal("existing file changed")
}
for _, path := range []string{"relative.sock", "tcp://127.0.0.1:80", parent + "/../reset.sock"} {
if server, err := Listen(path); err == nil {
_ = server.Close()
t.Fatalf("unsafe path accepted: %s", path)
}
}
}
func TestUnixActiveSocketCannotBeReplaced(t *testing.T) {
path := filepath.Join(t.TempDir(), "reset.sock")
first, err := Listen(path)
if err != nil {
t.Fatal(err)
}
defer first.Close()
if second, err := Listen(path); err == nil {
_ = second.Close()
t.Fatal("active socket replaced")
}
if _, err := Dial(context.Background(), path, uint32(os.Geteuid())+1); err == nil {
t.Fatal("wrong service identity accepted")
}
}
func TestUnixStaleOwnedSocketCanBeRecovered(t *testing.T) {
path := filepath.Join(t.TempDir(), "reset.sock")
old, err := net.ListenUnix("unix", &net.UnixAddr{Name: path, Net: "unix"})
if err != nil {
t.Fatal(err)
}
old.SetUnlinkOnClose(false)
if err := os.Chmod(path, 0600); err != nil {
t.Fatal(err)
}
if err := old.Close(); err != nil {
t.Fatal(err)
}
server, err := Listen(path)
if err != nil {
t.Fatal(err)
}
defer server.Close()
}
func TestUnixClosePreservesReplacedSocketPath(t *testing.T) {
path := filepath.Join(t.TempDir(), "reset.sock")
server, err := Listen(path)
if err != nil {
t.Fatal(err)
}
if err := os.Rename(path, path+".old"); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(path, []byte("replacement"), 0600); err != nil {
t.Fatal(err)
}
if err := server.Close(); !errors.Is(err, ErrUnauthorized) {
t.Fatalf("replacement not detected: %v", err)
}
data, err := os.ReadFile(path)
if err != nil || string(data) != "replacement" {
t.Fatal("replacement removed")
}
}
@@ -0,0 +1,170 @@
//go:build windows
package localreset
import (
"context"
"fmt"
"net"
"os"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/Microsoft/go-winio"
"golang.org/x/sys/windows"
)
func testWindowsPath() string {
return fmt.Sprintf(`\\.\pipe\scert-reset-test-%d-%d`, os.Getpid(), time.Now().UnixNano())
}
func currentWindowsPeer() (Peer, error) {
token, err := windows.OpenCurrentProcessToken()
if err != nil {
return Peer{}, err
}
defer token.Close()
return tokenPeer(token)
}
func startTestServer(t *testing.T, server *Server, factory Factory) {
t.Helper()
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() { done <- server.Serve(ctx, factory) }()
t.Cleanup(func() {
cancel()
_ = server.Close()
select {
case err := <-done:
if err != nil {
t.Error(err)
}
case <-time.After(time.Second):
t.Error("server failed to stop")
}
})
}
func TestWindowsNamedPipeRoundTrip(t *testing.T) {
if _, err := currentWindowsPeer(); err != nil {
t.Skip("requires elevated administrator or SYSTEM")
}
path := testWindowsPath()
server, err := Listen(path)
if err != nil {
t.Fatal(err)
}
session := &testSession{}
startTestServer(t, server, func(context.Context, Peer) (Session, error) { return session, nil })
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
conn, err := Dial(ctx, path, 0)
if err != nil {
t.Fatal(err)
}
client, err := Begin(ctx, conn)
if err != nil {
t.Fatal(err)
}
defer client.Close()
if err := client.Select("recovery"); err != nil {
t.Fatal(err)
}
if err := client.Verify("test-code"); err != nil {
t.Fatal(err)
}
if err := client.Reset("Example123!"); err != nil {
t.Fatal(err)
}
if session.resets.Load() != 1 {
t.Fatal("reset not applied")
}
}
func TestWindowsRejectsNonElevatedPeer(t *testing.T) {
if _, err := currentWindowsPeer(); err == nil {
t.Skip("requires non-elevated process")
}
path := testWindowsPath()
server, err := listenPipe(path, "D:P(A;;GA;;;WD)")
if err != nil {
t.Fatal(err)
}
var calls atomic.Int32
startTestServer(t, server, func(context.Context, Peer) (Session, error) {
calls.Add(1)
return &testSession{}, nil
})
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
conn, err := winio.DialPipeContext(ctx, path)
if err != nil {
t.Fatal(err)
}
if _, err := Begin(ctx, conn); err == nil {
t.Fatal("non-elevated client accepted")
}
if calls.Load() != 0 {
t.Fatal("non-elevated peer reached reset factory")
}
if conn, err := Dial(ctx, path, 0); err == nil {
_ = conn.Close()
t.Fatal("non-elevated server impersonation accepted")
}
}
func TestWindowsRejectsRemotePipePaths(t *testing.T) {
for _, path := range []string{`\\remote\pipe\scert-admin-control`, `tcp://127.0.0.1:80`, `\\.\pipe\`, `\\.\pipe\nested\pipe`} {
if _, err := pipePath(path); err == nil {
t.Fatalf("unsafe pipe accepted: %s", path)
}
}
if !strings.Contains(pipeSDDL, "(D;;GA;;;NU)") {
t.Fatal("network deny ACE missing")
}
}
func TestWindowsActivePipeCannotBeReplaced(t *testing.T) {
path := testWindowsPath()
first, err := listenPipe(path, "D:P(A;;GA;;;WD)")
if err != nil {
t.Fatal(err)
}
defer first.Close()
second, err := listenPipe(path, "D:P(A;;GA;;;WD)")
if err == nil {
_ = second.Close()
t.Fatal("active pipe replaced")
}
}
func TestServerShutdownClosesIdleConnections(t *testing.T) {
path := testWindowsPath()
server, err := listenPipe(path, "D:P(A;;GA;;;WD)")
if err != nil {
t.Fatal(err)
}
server.authorize = func(net.Conn) (Peer, error) { return Peer{Identity: "test"}, nil }
session := &testSession{}
startTestServer(t, server, func(context.Context, Peer) (Session, error) { return session, nil })
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
conn, err := winio.DialPipeContext(ctx, path)
if err != nil {
t.Fatal(err)
}
client, err := Begin(ctx, conn)
if err != nil {
t.Fatal(err)
}
defer client.Close()
if err := server.Close(); err != nil {
t.Fatal(err)
}
if err := client.Select("recovery"); err == nil {
t.Fatal("closed server accepted request")
}
}