Skip to content

Agent Mesh

fix(discovery): authorize exact-name GossipSub tool results

Rhein1 / Agoragentic681ccaee06ae
diff --git a/internal/node/mcp_handlers.go b/internal/node/mcp_handlers.go
index 7f216543..96beb28c 100644
--- a/internal/node/mcp_handlers.go
+++ b/internal/node/mcp_handlers.go
@@ -339,7 +339,8 @@ func (n *SamNode) handleFindRemoteTools(ctx context.Context, req *mcp.CallToolRe
if params.ToolName != "" && params.PeerID == "" && n.Discovery != nil {
n.Discovery.Ensure(api.ServiceType_SERVICE_TYPE_MCP, params.ToolName)
if provs := n.Discovery.Providers(api.ServiceType_SERVICE_TYPE_MCP, params.ToolName); len(provs) > 0 {
- rows = gossipToolRows(provs, params.ToolName, params.ServiceName)
+ candidates := gossipToolRows(provs, params.ToolName, params.ServiceName)
+ rows = n.verifyGossipToolRows(ctx, candidates)
if len(rows) > 0 {
return marshalToolRows(rows)
}
@@ -419,6 +420,84 @@ func gossipToolRows(provs []samdiscovery.Provider, toolName, serviceNameFilter s
return rows
}
+// verifyGossipToolRows treats unsolicited announcements as routing hints, not
+// authorization evidence. Each candidate is confirmed through the existing
+// authenticated MCP session and exact tools/list response before it is exposed.
+func (n *SamNode) verifyGossipToolRows(ctx context.Context, candidates []remoteToolRow) []remoteToolRow {
+ const maxConcurrent = 8
+
+ verifyCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+ defer cancel()
+
+ type verificationResult struct {
+ row remoteToolRow
+ ok bool
+ }
+ results := make([]verificationResult, len(candidates))
+ jobs := make(chan int)
+ workerCount := len(candidates)
+ if workerCount > maxConcurrent {
+ workerCount = maxConcurrent
+ }
+
+ var wg sync.WaitGroup
+ for range workerCount {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ for {
+ select {
+ case index, ok := <-jobs:
+ if !ok {
+ return
+ }
+ candidate := candidates[index]
+ pid, err := peer.Decode(candidate.PeerID)
+ if err != nil {
+ logger.Debugf("[find_remote_tools] invalid gossip peer %q skipped: %v", candidate.PeerID, err)
+ continue
+ }
+ description, err := n.fetchRemoteToolDescription(verifyCtx, pid, candidate.ToolName)
+ if err != nil {
+ logger.Debugf("[find_remote_tools] unverified gossip candidate %s on %s skipped: %v", candidate.ToolName, pid, err)
+ continue
+ }
+ results[index] = verificationResult{
+ ok: true,
+ row: remoteToolRow{
+ PeerID: description.PeerID,
+ ToolName: description.ToolName,
+ Description: description.Description,
+ Labels: candidate.Labels,
+ },
+ }
+ case <-verifyCtx.Done():
+ return
+ }
+ }
+ }()
+ }
+
+sendCandidates:
+ for index := range candidates {
+ select {
+ case jobs <- index:
+ case <-verifyCtx.Done():
+ break sendCandidates
+ }
+ }
+ close(jobs)
+ wg.Wait()
+
+ rows := make([]remoteToolRow, 0, len(results))
+ for _, result := range results {
+ if result.ok {
+ rows = append(rows, result.row)
+ }
+ }
+ return rows
+}
+
// filterRowsByToolName keeps rows whose namespaced tool name ends in the
// bare tool name; error rows (no tool listing) are dropped from targeted
// lookups.
@@ -592,66 +671,73 @@ type DescribeRemoteToolParams struct {
ToolName string `json:"tool_name" jsonschema:"Namespaced server name as returned by find_remote_tools (e.g. 'mcp://code-reviewer/review_pr'). Required."`
}
-// handleDescribeRemoteTool implements the describe_remote_tool client-facing tool.
-func (n *SamNode) handleDescribeRemoteTool(ctx context.Context, req *mcp.CallToolRequest, params DescribeRemoteToolParams) (*mcp.CallToolResult, any, error) {
- if params.PeerID == "" {
- return nil, nil, fmt.Errorf("peer_id is required")
- }
- if params.ToolName == "" {
- return nil, nil, fmt.Errorf("tool_name is required")
- }
-
- pid, err := peer.Decode(params.PeerID)
+func (n *SamNode) fetchRemoteToolDescription(ctx context.Context, pid peer.ID, toolName string) (*remoteToolDescription, error) {
+ serviceName, actualToolName, err := api.SplitToolName(toolName)
if err != nil {
- return nil, nil, fmt.Errorf("invalid peer_id: %w", err)
- }
-
- serviceName, actualToolName, err := api.SplitToolName(params.ToolName)
- if err != nil {
- return nil, nil, err
+ return nil, err
}
if serviceName == "system://"+api.CatalogTarget {
- return nil, nil, fmt.Errorf("cannot describe system catalog tools via describe_remote_tool")
+ return nil, fmt.Errorf("cannot describe system catalog tools via describe_remote_tool")
}
n.preparePeerAddrs(ctx, pid)
session, cleanup, err := n.ConnectMCPSession(ctx, pid, serviceName, nil)
if err != nil {
- return nil, nil, err
+ return nil, err
}
defer cleanup()
listRes, err := session.ListTools(ctx, nil)
if err != nil {
- return nil, nil, err
+ return nil, err
}
if listRes == nil {
- return nil, nil, fmt.Errorf("list tools response was nil")
+ return nil, fmt.Errorf("list tools response was nil")
}
- for _, t := range listRes.Tools {
- if t == nil {
+ for _, tool := range listRes.Tools {
+ if tool == nil {
continue
}
- if t.Name == actualToolName {
- payload := remoteToolDescription{
+ if tool.Name == actualToolName {
+ return &remoteToolDescription{
PeerID: pid.String(),
- ToolName: params.ToolName,
- Description: t.Description,
- InputSchema: t.InputSchema,
- OutputSchema: t.OutputSchema,
- }
- data, err := json.Marshal(payload)
- if err != nil {
- return nil, nil, err
- }
- return &mcp.CallToolResult{
- Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},
- }, nil, nil
+ ToolName: toolName,
+ Description: tool.Description,
+ InputSchema: tool.InputSchema,
+ OutputSchema: tool.OutputSchema,
+ }, nil
}
}
- return nil, nil, fmt.Errorf("tool not found on peer")
+ return nil, fmt.Errorf("tool not found on peer")
+}
+
+// handleDescribeRemoteTool implements the describe_remote_tool client-facing tool.
+func (n *SamNode) handleDescribeRemoteTool(ctx context.Context, req *mcp.CallToolRequest, params DescribeRemoteToolParams) (*mcp.CallToolResult, any, error) {
+ if params.PeerID == "" {
+ return nil, nil, fmt.Errorf("peer_id is required")
+ }
+ if params.ToolName == "" {
+ return nil, nil, fmt.Errorf("tool_name is required")
+ }
+
+ pid, err := peer.Decode(params.PeerID)
+ if err != nil {
+ return nil, nil, fmt.Errorf("invalid peer_id: %w", err)
+ }
+
+ payload, err := n.fetchRemoteToolDescription(ctx, pid, params.ToolName)
+ if err != nil {
+ return nil, nil, err
+ }
+ data, err := json.Marshal(payload)
+ if err != nil {
+ return nil, nil, err
+ }
+ return &mcp.CallToolResult{
+ Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},
+ }, nil, nil
}
// CheckConnectivityParams defines the parameters for the check_connectivity tool.
diff --git a/internal/node/mcp_handlers_test.go b/internal/node/mcp_handlers_test.go
index c861e3ec..4c07ee18 100644
--- a/internal/node/mcp_handlers_test.go
+++ b/internal/node/mcp_handlers_test.go
@@ -516,6 +516,70 @@ func TestFetchRemoteToolCatalogue_AuthRejectedHidden(t *testing.T) {
}
}
+func TestVerifyGossipToolRows_AuthenticatesEachServiceOnSamePeer(t *testing.T) {
+ ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+ defer cancel()
+
+ allowedSrv := httptest.NewServer(newFakeMCPHandler(t, []*mcp.Tool{
+ {Name: "review_pr", Description: "authorized review", InputSchema: map[string]any{"type": "object"}},
+ }))
+ defer allowedSrv.Close()
+ deniedSrv := httptest.NewServer(newFakeMCPHandler(t, []*mcp.Tool{
+ {Name: "review_pr", Description: "unauthorized review", InputSchema: map[string]any{"type": "object"}},
+ }))
+ defer deniedSrv.Close()
+
+ nodeA, cleanupA := startBareNode(t, ctx)
+ defer cleanupA()
+ nodeB, cleanupB := startBareNode(t, ctx)
+ defer cleanupB()
+
+ rootPub, rootPriv, err := ed25519.GenerateKey(rand.Reader)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := buildAndSaveCustomBiscuit(nodeA, rootPriv, []string{"mcp://allowed-reviewer"}); err != nil {
+ t.Fatalf("buildAndSaveCustomBiscuit: %v", err)
+ }
+ nodeB.keysMu.Lock()
+ nodeB.trustedKeys = append(nodeB.trustedKeys, TrustedKey{Key: rootPub, ReceivedAt: time.Now()})
+ nodeB.keysMu.Unlock()
+ if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: nodeB.Host.ID(), Addrs: nodeB.Host.Addrs()}); err != nil {
+ t.Fatal(err)
+ }
+
+ for name, targetURL := range map[string]string{
+ "allowed-reviewer": allowedSrv.URL,
+ "denied-reviewer": deniedSrv.URL,
+ } {
+ if err := nodeB.RegisterService(ctx, &api.RegisterServiceRequest{
+ Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: name},
+ Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: targetURL},
+ }); err != nil {
+ t.Fatalf("RegisterService %s: %v", name, err)
+ }
+ }
+
+ peerID := nodeB.Host.ID().String()
+ rows := nodeA.verifyGossipToolRows(ctx, []remoteToolRow{
+ {PeerID: peerID, ToolName: "mcp://allowed-reviewer/review_pr", Labels: map[string]string{"region": "us"}},
+ {PeerID: peerID, ToolName: "mcp://denied-reviewer/review_pr", Labels: map[string]string{"region": "us"}},
+ })
+
+ if len(rows) != 1 {
+ t.Fatalf("expected one authorized row, got %d: %+v", len(rows), rows)
+ }
+ if rows[0].ToolName != "mcp://allowed-reviewer/review_pr" {
+ t.Fatalf("unexpected verified tool: %+v", rows[0])
+ }
+ if rows[0].Description != "authorized review" {
+ t.Errorf("Description = %q, want authorized review", rows[0].Description)
+ }
+ if rows[0].Labels["region"] != "us" {
+ t.Errorf("gossip routing labels were not preserved: %+v", rows[0].Labels)
+ }
+}
+
func TestCallMCPTool_LabelEnforcement(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()