Files
SimpleRemoter/server/go/mcp/lock_test.go
T
yuanyuanxianganddeepseek-flash 1076e7614a Feature(Go): per-device locks, a global call gate and tool-call audit
Add the three cross-cutting guards the Go MCP endpoint needs before any
tool talks to a client. Each tools/call now takes one of MaxConcurrency
global slots and, for single-host tools, that host's device lock; both are
non-blocking, so contention returns -32003 instead of queueing. Panicking
handlers are converted to -32000 rather than dropping the connection.

Write one mcp.tool.call audit record per named call, including rejected
ones: actor/role/source, tool, device, ok/code, duration, a size-only
result summary and a truncated argument digest. Commands keep only their
first word plus length, and free-form or credential fields (text, message,
body, headers, password, token) are replaced by their size, so secrets do
not reach the audit file.

Co-Authored-By: deepseek-flash
2026-11-12 21:05:37 +01:00

311 lines
9.7 KiB
Go

package mcp
import (
"context"
"encoding/json"
"os"
"path/filepath"
"strings"
"sync"
"testing"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/logger"
)
// blockingListFiles installs a list_files handler that blocks while id ==
// blockID, so a second call for that host can be checked against the lock.
func blockingListFiles(t *testing.T, s *Server, blockID string) (entered chan struct{}, release func()) {
t.Helper()
entered = make(chan struct{})
done := make(chan struct{})
var once sync.Once
s.handlers["list_files"] = func(_ context.Context, args json.RawMessage) (any, *rpcError) {
var a struct {
ID string `json:"id"`
}
_ = json.Unmarshal(args, &a)
if a.ID == blockID {
once.Do(func() { close(entered) })
<-done
}
return newToolResult("ok", map[string]any{"id": a.ID}), nil
}
return entered, func() { close(done) }
}
func listFilesCall(t *testing.T, s *Server, id string) (any, *rpcError) {
t.Helper()
return s.callTool(context.Background(), json.RawMessage(
`{"name":"list_files","arguments":{"id":"`+id+`","path":"/"}}`))
}
func TestDeviceLockRejectsSecondCall(t *testing.T) {
s := testServer(t, false)
entered, release := blockingListFiles(t, s, "1001")
type outcome struct {
res any
err *rpcError
}
first := make(chan outcome, 1)
go func() {
res, rerr := listFilesCall(t, s, "1001")
first <- outcome{res, rerr}
}()
<-entered
_, rerr := listFilesCall(t, s, "1001")
if rerr == nil || rerr.Code != CodeBusy {
t.Fatalf("second same-host call error = %+v, want -32003", rerr)
}
if !strings.Contains(rerr.Message, "tool=list_files") || !strings.Contains(rerr.Message, "elapsed=") {
t.Fatalf("busy message = %q, want tool and elapsed", rerr.Message)
}
// A different host is a different lock and must not be blocked.
if _, rerr = listFilesCall(t, s, "2002"); rerr != nil {
t.Fatalf("other-host call error = %+v, want success", rerr)
}
release()
if got := <-first; got.err != nil {
t.Fatalf("first call error = %+v, want success", got.err)
}
// The lock is released once the call returns.
if _, rerr = listFilesCall(t, s, "1001"); rerr != nil {
t.Fatalf("call after release error = %+v, want success", rerr)
}
}
func TestDeviceLockReleasedOnContextCancel(t *testing.T) {
s := testServer(t, false)
entered := make(chan struct{})
var once sync.Once
s.handlers["list_files"] = func(ctx context.Context, _ json.RawMessage) (any, *rpcError) {
once.Do(func() { close(entered) })
<-ctx.Done()
return nil, errf(CodeTimeout, "request cancelled")
}
ctx, cancel := context.WithCancel(context.Background())
done := make(chan struct{})
go func() {
defer close(done)
_, _ = s.callTool(ctx, json.RawMessage(
`{"name":"list_files","arguments":{"id":"1001"}}`))
}()
<-entered
cancel()
<-done
// Replace the cancelling handler before reusing the host: the lock must
// already be free, and this handler returns immediately.
s.handlers["list_files"] = func(_ context.Context, _ json.RawMessage) (any, *rpcError) {
return newToolResult("ok", map[string]any{"id": "1001"}), nil
}
if _, rerr := listFilesCall(t, s, "1001"); rerr != nil {
t.Fatalf("call after cancel error = %+v, want success (lock must be free)", rerr)
}
}
func TestGlobalConcurrencyGate(t *testing.T) {
log := logger.New(logger.Config{Level: logger.LevelError,
File: filepath.Join(t.TempDir(), "mcp-test.log")})
t.Cleanup(func() { _ = log.Close() })
s := New(Config{Token: testToken, MaxConcurrency: 1, Log: log})
entered, release := blockingListFiles(t, s, "1001")
type outcome struct {
res any
err *rpcError
}
first := make(chan outcome, 1)
go func() {
res, rerr := listFilesCall(t, s, "1001")
first <- outcome{res, rerr}
}()
<-entered
// A different host still needs a global slot, and there is only one.
_, rerr := listFilesCall(t, s, "2002")
if rerr == nil || rerr.Code != CodeBusy {
t.Fatalf("second call error = %+v, want -32003", rerr)
}
if !strings.Contains(rerr.Message, "concurrent") {
t.Fatalf("concurrency message = %q", rerr.Message)
}
release()
if got := <-first; got.err != nil {
t.Fatalf("first call error = %+v", got.err)
}
if _, rerr = listFilesCall(t, s, "2002"); rerr != nil {
t.Fatalf("call after slot freed error = %+v, want success", rerr)
}
}
// readAuditRecords returns the audit JSON lines written so far.
func readAuditRecords(t *testing.T, path string) []map[string]any {
t.Helper()
data, err := os.ReadFile(path)
if err != nil {
t.Fatalf("read audit file: %v", err)
}
var out []map[string]any
for line := range strings.SplitSeq(strings.TrimSpace(string(data)), "\n") {
if line == "" {
continue
}
var rec map[string]any
if err := json.Unmarshal([]byte(line), &rec); err != nil {
t.Fatalf("parse audit line %q: %v", line, err)
}
out = append(out, rec)
}
return out
}
func TestToolCallAudit(t *testing.T) {
dir := t.TempDir()
auditPath := filepath.Join(dir, "audit.log")
log := logger.New(logger.Config{
Level: logger.LevelError,
File: filepath.Join(dir, "server.log"),
AuditFile: auditPath,
})
t.Cleanup(func() { _ = log.Close() })
s := New(Config{Token: testToken, Log: log})
s.handlers["terminal_exec"] = func(_ context.Context, _ json.RawMessage) (any, *rpcError) {
return newToolResult("done", map[string]any{"output": "secret-output"}), nil
}
text, _, rerr := callLocal(t, s, "terminal_exec",
`{"id":"1001","command":"mysql -pTopSecret --batch"}`)
if rerr != nil {
t.Fatalf("terminal_exec error = %+v (text %q)", rerr, text)
}
if _, _, rerr = callLocal(t, s, "nope", `{}`); rerr == nil || rerr.Code != CodeMethodNotFound {
t.Fatalf("unknown tool error = %+v, want -32601", rerr)
}
// A local tool has no device and must audit device "-".
if _, _, rerr = callLocal(t, s, "get_server_status", `{}`); rerr != nil {
t.Fatalf("get_server_status error = %+v", rerr)
}
recs := readAuditRecords(t, auditPath)
if len(recs) != 3 {
t.Fatalf("audit records = %d, want 3", len(recs))
}
ok := recs[0]
if ok["event"] != "mcp.tool.call" || ok["actor"] != "mcp" || ok["role"] != "admin" || ok["source"] != "mcp" {
t.Fatalf("identity fields = %v", ok)
}
if ok["tool"] != "terminal_exec" || ok["device"] != "1001" {
t.Fatalf("tool/device = %v/%v", ok["tool"], ok["device"])
}
if ok["ok"] != true || ok["code"].(float64) != 0 {
t.Fatalf("ok/code = %v/%v", ok["ok"], ok["code"])
}
if _, hasMS := ok["ms"]; !hasMS {
t.Fatal("missing ms")
}
args, _ := ok["args"].(string)
if !strings.Contains(args, "mysql (len=") {
t.Fatalf("args = %q, want first word + length", args)
}
if strings.Contains(args, "TopSecret") {
t.Fatalf("args leaked the command body: %q", args)
}
if res, _ := ok["result"].(string); !strings.Contains(res, "bytes") {
t.Fatalf("result = %q, want byte summary", res)
}
bad := recs[1]
if bad["tool"] != "nope" || bad["ok"] != false || bad["code"].(float64) != CodeMethodNotFound {
t.Fatalf("failed call record = %v", bad)
}
if bad["device"] != "-" {
t.Fatalf("unknown tool device = %v, want -", bad["device"])
}
if res, _ := bad["result"].(string); !strings.Contains(res, "unknown tool") {
t.Fatalf("failure result = %q", res)
}
local := recs[2]
if local["tool"] != "get_server_status" || local["device"] != "-" || local["ok"] != true {
t.Fatalf("local tool record = %v", local)
}
}
// A panicking handler must not take the connection down and must not be
// audited as a success.
func TestToolCallPanicAuditedAsFailure(t *testing.T) {
dir := t.TempDir()
auditPath := filepath.Join(dir, "audit.log")
log := logger.New(logger.Config{
Level: logger.LevelError,
File: filepath.Join(dir, "server.log"),
AuditFile: auditPath,
})
t.Cleanup(func() { _ = log.Close() })
s := New(Config{Token: testToken, Log: log})
s.handlers["terminal_exec"] = func(_ context.Context, _ json.RawMessage) (any, *rpcError) {
panic("boom")
}
if _, rerr := s.callTool(context.Background(), json.RawMessage(
`{"name":"terminal_exec","arguments":{"id":"1001","command":"dir"}}`)); rerr == nil ||
rerr.Code != CodeInternal {
t.Fatalf("panic call error = %+v, want -32000", rerr)
}
recs := readAuditRecords(t, auditPath)
if len(recs) != 1 {
t.Fatalf("audit records = %d, want 1", len(recs))
}
if recs[0]["ok"] != false || recs[0]["code"].(float64) != CodeInternal {
t.Fatalf("panic record = %v, want ok=false code=-32000", recs[0])
}
// The host lock must be free again despite the panic.
s.handlers["terminal_exec"] = func(_ context.Context, _ json.RawMessage) (any, *rpcError) {
return newToolResult("ok", nil), nil
}
if _, rerr := s.callTool(context.Background(), json.RawMessage(
`{"name":"terminal_exec","arguments":{"id":"1001"}}`)); rerr != nil {
t.Fatalf("call after panic error = %+v, want success", rerr)
}
}
func TestSummarizeArgsRedactsSensitiveValues(t *testing.T) {
got := summarizeArgs(json.RawMessage(`{
"id": "1001",
"command": "mysql -pTopSecret --batch",
"text": "hello secret",
"message": "msg secret",
"body": "{\"key\":\"secret\"}",
"headers": {"Authorization": "Bearer tok"},
"password": "pw"
}`))
for _, leak := range []string{"TopSecret", "hello secret", "msg secret", "Bearer tok", "pw"} {
if strings.Contains(got, leak) {
t.Fatalf("args leaked %q: %s", leak, got)
}
}
if !strings.Contains(got, "mysql (len=") {
t.Fatalf("command digest missing: %s", got)
}
if !strings.Contains(got, "redacted(") {
t.Fatalf("redaction marker missing: %s", got)
}
if len(got) > auditArgsMaxBytes {
t.Fatalf("digest = %d bytes, want <= %d", len(got), auditArgsMaxBytes)
}
// The ellipsis counts toward the cap.
long := summarizeArgs(json.RawMessage(`{"note":"` + strings.Repeat("a", 800) + `"}`))
if len(long) > auditArgsMaxBytes || !strings.HasSuffix(long, "…") {
t.Fatalf("truncated digest = %d bytes, tail %q", len(long), long[len(long)-3:])
}
}