Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package node
import (
"bytes"
"context"
"crypto/ed25519"
"crypto/rand"
"crypto/tls"
"crypto/x509"
"net/http"
"net/http/httptest"
"testing"
"time"
"github.com/google/agentmesh/api"
"github.com/google/agentmesh/internal/identity"
lru "github.com/hashicorp/golang-lru/v2"
"github.com/libp2p/go-libp2p"
"google.golang.org/protobuf/encoding/protojson"
)
func newIdentityEvidenceTestNode(t *testing.T, labels map[string]string) (*AgentMeshNode, ed25519.PrivateKey, time.Time) {
t.Helper()
host, err := libp2p.New()
if err != nil {
t.Fatalf("create libp2p host: %v", err)
}
t.Cleanup(func() { _ = host.Close() })
controlPlanePublic, controlPlanePrivate, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Fatalf("generate control-plane key: %v", err)
}
expiresAt := time.Now().UTC().Add(time.Hour).Truncate(time.Second)
biscuitBytes, err := identity.MintBootstrapBiscuitToken(controlPlanePrivate, host.ID(), api.RoleNode, expiresAt, nil, labels)
if err != nil {
t.Fatalf("mint identity biscuit: %v", err)
}
store, err := NewStore(t.TempDir())
if err != nil {
t.Fatalf("create store: %v", err)
}
t.Cleanup(func() { _ = store.Close() })
if err := store.SaveIdentity(biscuitBytes); err != nil {
t.Fatalf("save identity: %v", err)
}
if err := store.SaveControlPlaneURL("https://cp.example"); err != nil {
t.Fatalf("save control-plane URL: %v", err)
}
revokedPeers, err := lru.New[string, int64](16)
if err != nil {
t.Fatalf("create revocation cache: %v", err)
}
node := &AgentMeshNode{
Host: host,
Store: store,
trustedKeys: []TrustedKey{{Key: controlPlanePublic, ReceivedAt: time.Now().UTC().Add(-time.Minute)}},
revokedPeers: revokedPeers,
BiscuitTimeout: time.Second,
}
node.SetIdentityCache(biscuitBytes)
return node, controlPlanePrivate, expiresAt
}
func localSocketRequest(method, target string) *http.Request {
request := httptest.NewRequest(method, target, nil)
return request.WithContext(context.WithValue(request.Context(), localSocketContextKey{}, true))
}
func TestIdentityEvidenceRequiresStrongTransport(t *testing.T) {
node, _, _ := newIdentityEvidenceTestNode(t, nil)
handler := requireIdentityEvidenceTransport(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
handleIdentityEvidence(node, w, r)
}))
plainRecorder := httptest.NewRecorder()
handler.ServeHTTP(plainRecorder, httptest.NewRequest(http.MethodGet, "/mesh/identity", nil))
if plainRecorder.Code != http.StatusForbidden {
t.Fatalf("plain TCP status = %d, want %d", plainRecorder.Code, http.StatusForbidden)
}
if got := plainRecorder.Header().Get("Content-Type"); got != "text/plain; charset=utf-8" {
t.Fatalf("plain TCP content type = %q, want text/plain", got)
}
socketRecorder := httptest.NewRecorder()
handler.ServeHTTP(socketRecorder, localSocketRequest(http.MethodGet, "/mesh/identity"))
if socketRecorder.Code != http.StatusOK {
t.Fatalf("socket status = %d, body = %s", socketRecorder.Code, socketRecorder.Body.String())
}
mtlsRequest := httptest.NewRequest(http.MethodGet, "/mesh/identity", nil)
mtlsRequest.TLS = &tls.ConnectionState{VerifiedChains: [][]*x509.Certificate{{{}}}}
mtlsRecorder := httptest.NewRecorder()
handler.ServeHTTP(mtlsRecorder, mtlsRequest)
if mtlsRecorder.Code != http.StatusOK {
t.Fatalf("mTLS status = %d, body = %s", mtlsRecorder.Code, mtlsRecorder.Body.String())
}
}
func TestIdentityEvidenceReturnsVerifiableClosedResponse(t *testing.T) {
node, _, expiresAt := newIdentityEvidenceTestNode(t, map[string]string{"region": "us-east-1"})
recorder := httptest.NewRecorder()
handleIdentityEvidence(node, recorder, localSocketRequest(http.MethodGet, "/mesh/identity"))
if recorder.Code != http.StatusOK {
t.Fatalf("status = %d, body = %s", recorder.Code, recorder.Body.String())
}
var response api.IdentityEvidenceResponse
if err := protojson.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
t.Fatalf("decode response: %v", err)
}
if response.PeerId != node.Host.ID().String() || len(response.Biscuit) == 0 {
t.Fatalf("unexpected identity response: peer=%q biscuit=%d", response.PeerId, len(response.Biscuit))
}
if response.GetBiscuitExpireTime().AsTime().Unix() != expiresAt.Unix() || len(response.TrustedControlPlaneKeys) != 1 {
t.Fatalf("unexpected expiry or key set: expiry=%v keys=%d", response.GetBiscuitExpireTime().AsTime(), len(response.TrustedControlPlaneKeys))
}
parsedKey, err := x509.ParsePKIXPublicKey(response.TrustedControlPlaneKeys[0])
if err != nil {
t.Fatalf("parse SPKI: %v", err)
}
publicKey, ok := parsedKey.(ed25519.PublicKey)
if !ok || !publicKey.Equal(node.trustedKeys[0].Key) {
t.Fatalf("trusted control-plane key is not the enrolled key")
}
if response.CheckTime == nil || response.CheckTime.AsTime().After(response.GetBiscuitExpireTime().AsTime()) {
t.Fatalf("invalid check/expiry times: check=%v expiry=%v", response.GetCheckTime().AsTime(), response.GetBiscuitExpireTime().AsTime())
}
}
func TestBuildIdentityEvidenceFailsClosedWhenLocalPeerIsRevoked(t *testing.T) {
node, _, _ := newIdentityEvidenceTestNode(t, nil)
node.revokedPeers.Add(node.Host.ID().String(), time.Now().Unix())
if _, err := node.buildIdentityEvidence(time.Now().UTC()); err == nil {
t.Fatal("revoked local peer must not produce identity evidence")
}
}
func TestBuildPeerEvidenceBindsRequestedConnectionAndBiscuitPeers(t *testing.T) {
node, controlPlanePrivate, expiresAt := newIdentityEvidenceTestNode(t, nil)
provider, err := libp2p.New()
if err != nil {
t.Fatalf("create provider host: %v", err)
}
t.Cleanup(func() { _ = provider.Close() })
providerBiscuit, err := identity.MintBootstrapBiscuitToken(controlPlanePrivate, provider.ID(), api.RoleNode, expiresAt, nil, map[string]string{"region": "us-east-1"})
if err != nil {
t.Fatalf("mint provider biscuit: %v", err)
}
response, err := node.buildPeerEvidence(provider.ID(), peerBiscuitObservation{
Biscuit: providerBiscuit,
ConnectionPeer: provider.ID(),
}, time.Now().UTC())
if err != nil {
t.Fatalf("build peer evidence: %v", err)
}
if response.PeerId != provider.ID().String() || !bytes.Equal(response.Biscuit, providerBiscuit) {
t.Fatalf("unexpected peer binding: %+v", response)
}
if response.Labels["region"] != "us-east-1" || len(response.RevocationIds) == 0 {
t.Fatalf("missing attestation or revocation evidence: %+v", response)
}
if response.GetExpireTime().AsTime().Unix() != expiresAt.Unix() || response.CheckTime == nil || response.CheckTime.AsTime().After(response.GetExpireTime().AsTime()) {
t.Fatalf("invalid check/expiry times: check=%v expiry=%v", response.GetCheckTime().AsTime(), response.GetExpireTime().AsTime())
}
parsedKey, err := x509.ParsePKIXPublicKey(response.VerifyingKey)
if err != nil {
t.Fatalf("parse verifying key SPKI: %v", err)
}
publicKey, ok := parsedKey.(ed25519.PublicKey)
if !ok || !publicKey.Equal(node.trustedKeys[0].Key) {
t.Fatalf("peer evidence verifying key is not in the trusted set")
}
}
func TestBuildPeerEvidenceFailsClosedOnBindingRevocationAndKeyRotation(t *testing.T) {
node, controlPlanePrivate, expiresAt := newIdentityEvidenceTestNode(t, nil)
provider, _ := libp2p.New()
t.Cleanup(func() { _ = provider.Close() })
other, _ := libp2p.New()
t.Cleanup(func() { _ = other.Close() })
providerBiscuit, err := identity.MintBootstrapBiscuitToken(controlPlanePrivate, provider.ID(), api.RoleNode, expiresAt, nil, nil)
if err != nil {
t.Fatalf("mint provider biscuit: %v", err)
}
observation := peerBiscuitObservation{Biscuit: providerBiscuit, ConnectionPeer: provider.ID()}
if _, err := node.buildPeerEvidence(other.ID(), observation, time.Now().UTC()); err == nil {
t.Fatalf("requested/connection mismatch must fail closed")
}
node.revokedPeers.Add(provider.ID().String(), time.Now().Unix())
if _, err := node.buildPeerEvidence(provider.ID(), observation, time.Now().UTC()); err == nil {
t.Fatalf("revoked peer must fail closed")
}
node.revokedPeers.Remove(provider.ID().String())
newPublic, _, _ := ed25519.GenerateKey(rand.Reader)
node.keysMu.Lock()
node.trustedKeys = []TrustedKey{{Key: newPublic, ReceivedAt: time.Now().UTC()}}
node.keysMu.Unlock()
if _, err := node.buildPeerEvidence(provider.ID(), observation, time.Now().UTC()); err == nil {
t.Fatalf("untrusted signing key must fail closed")
}
}