Skip to content

Agent Mesh

node: allow suppressing private address announcements

Antonio Ojead172bb32bed6
diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.go
index 7e9f6e71..f2d325c9 100644
--- a/cmd/sam-node/main.go
+++ b/cmd/sam-node/main.go
@@ -78,6 +78,7 @@ var (
logLevelFlag string
keyGracePeriodFlag time.Duration
allowLoopbackFlag bool
+ announcePrivateFlag bool
monitorBootstrapFlag time.Duration
monitorCheckIntervalFlag time.Duration
autoRelayMinIntervalFlag time.Duration
@@ -409,6 +410,7 @@ func main() {
NodeConfig: nodeConfig,
KeyGracePeriod: keyGracePeriodFlag,
AllowLoopback: allowLoopbackFlag,
+ AnnouncePrivateAddrs: &announcePrivateFlag,
MonitorBootstrap: monitorBootstrapFlag,
MonitorInterval: monitorCheckIntervalFlag,
AutoRelayMinInterval: autoRelayMinIntervalFlag,
@@ -475,6 +477,7 @@ func main() {
NodeConfig: nodeConfig,
KeyGracePeriod: keyGracePeriodFlag,
AllowLoopback: allowLoopbackFlag,
+ AnnouncePrivateAddrs: &announcePrivateFlag,
MonitorBootstrap: monitorBootstrapFlag,
MonitorInterval: monitorCheckIntervalFlag,
AutoRelayMinInterval: autoRelayMinIntervalFlag,
@@ -543,6 +546,7 @@ func main() {
NodeConfig: nodeConfig,
KeyGracePeriod: keyGracePeriodFlag,
AllowLoopback: allowLoopbackFlag,
+ AnnouncePrivateAddrs: &announcePrivateFlag,
MonitorBootstrap: monitorBootstrapFlag,
MonitorInterval: monitorCheckIntervalFlag,
AutoRelayMinInterval: autoRelayMinIntervalFlag,
@@ -695,6 +699,7 @@ func main() {
NodeConfig: nodeConfig,
KeyGracePeriod: keyGracePeriodFlag,
AllowLoopback: allowLoopbackFlag,
+ AnnouncePrivateAddrs: &announcePrivateFlag,
MonitorBootstrap: 2 * time.Minute,
MonitorInterval: 1 * time.Minute,
AutoRelayMinInterval: 30 * time.Second,
@@ -806,8 +811,10 @@ func main() {
runCmd.Flags().StringVar(&logLevelFlag, "log-level", "info", "Log level (debug, info, warn, error)")
runCmd.Flags().DurationVar(&keyGracePeriodFlag, "key-grace-period", 24*time.Hour, "Key grace period for old keys (e.g. 24h)")
runCmd.Flags().BoolVar(&allowLoopbackFlag, "allow-loopback", false, "Allow publishing and connecting to loopback/link-local addresses")
+ runCmd.Flags().BoolVar(&announcePrivateFlag, "announce-private", true, "Publish this host's private (RFC1918/ULA) addresses to the mesh; keep enabled for LAN or on-premises meshes, disable when peers are only reachable through routers or public addresses")
runCmd.Flags().BoolVar(&offlineAccessFlag, "offline-access", false, "With --join, request OIDC offline access/refresh token for automatic renewal")
joinCmd.Flags().BoolVar(&allowLoopbackFlag, "allow-loopback", false, "Allow publishing and connecting to loopback/link-local addresses")
+ joinCmd.Flags().BoolVar(&announcePrivateFlag, "announce-private", true, "Publish this host's private (RFC1918/ULA) addresses to the mesh; keep enabled for LAN or on-premises meshes, disable when peers are only reachable through routers or public addresses")
joinCmd.Flags().DurationVar(&routerConnectTimeoutFlag, "router-connect-timeout", node.DefaultRouterConnectTimeout, "Timeout for dialing each router address")
joinCmd.Flags().BoolVar(&offlineAccessFlag, "offline-access", false, "Request OIDC offline access/refresh token for automatic renewal")
joinCmd.Flags().StringVar(&bootstrapTokenFlag, "bootstrap-token", "", "Pre-shared bootstrap token for enrollment")
diff --git a/internal/node/node.go b/internal/node/node.go
index cf850958..f25da3fc 100644
--- a/internal/node/node.go
+++ b/internal/node/node.go
@@ -324,18 +324,7 @@ func (n *SamNode) Start(ctx context.Context) error {
libp2p.EnableHolePunching(),
libp2p.ConnectionManager(cm),
libp2p.SwarmOpts(swarm.WithDialTimeout(15 * time.Second)),
- libp2p.AddrsFactory(func(addrs []multiaddr.Multiaddr) []multiaddr.Multiaddr {
- if n.config.AllowLoopback {
- return addrs
- }
- var filtered []multiaddr.Multiaddr
- for _, addr := range addrs {
- if !isLoopbackOrLinkLocal(addr) {
- filtered = append(filtered, addr)
- }
- }
- return filtered
- }),
+ libp2p.AddrsFactory(n.announceFilter),
}
// If we have routers, configure them as our static fallback relays for NAT hole-punching
@@ -1930,6 +1919,32 @@ func (n *SamNode) StartIngressServer(ctx context.Context) error {
return nil
}
+// announceFilter selects which of the host's addresses are published to the
+// mesh (via Identify and DHT provider records). Relay addresses always pass:
+// their IP belongs to the router, and dropping one would strand a node behind
+// NAT.
+func (n *SamNode) announceFilter(addrs []multiaddr.Multiaddr) []multiaddr.Multiaddr {
+ announcePrivate := n.config.AnnouncePrivateAddrs == nil || *n.config.AnnouncePrivateAddrs
+ if n.config.AllowLoopback && announcePrivate {
+ return addrs
+ }
+ var filtered []multiaddr.Multiaddr
+ for _, addr := range addrs {
+ if hasCircuit(addr) {
+ filtered = append(filtered, addr)
+ continue
+ }
+ if !n.config.AllowLoopback && isLoopbackOrLinkLocal(addr) {
+ continue
+ }
+ if !announcePrivate && isPrivateIP(addr) {
+ continue
+ }
+ filtered = append(filtered, addr)
+ }
+ return filtered
+}
+
func isLoopbackOrLinkLocal(addr multiaddr.Multiaddr) bool {
for _, proto := range addr.Protocols() {
if proto.Code != multiaddr.P_IP4 && proto.Code != multiaddr.P_IP6 {
diff --git a/internal/node/node_test.go b/internal/node/node_test.go
index 00be2bb4..b3fa0123 100644
--- a/internal/node/node_test.go
+++ b/internal/node/node_test.go
@@ -25,8 +25,82 @@ import (
"github.com/google/sam/api"
lru "github.com/hashicorp/golang-lru/v2"
"github.com/libp2p/go-libp2p/core/crypto"
+ "github.com/multiformats/go-multiaddr"
)
+func TestAnnounceFilter(t *testing.T) {
+ const (
+ loopback = "/ip4/127.0.0.1/tcp/5002"
+ linkLocal = "/ip4/169.254.10.1/tcp/5002"
+ private = "/ip4/192.168.94.13/tcp/5002"
+ public = "/ip4/34.91.220.211/udp/8192/quic-v1"
+ // Relay path whose router sits on a private address, as in an on-premises mesh.
+ circuit = "/ip4/10.0.0.7/tcp/4501/p2p/12D3KooWG1pA6goegCncqwbZLSr8pnjUZ6JMAAe6SmnHTgUNCk88/p2p-circuit"
+ )
+ input := []multiaddr.Multiaddr{}
+ for _, s := range []string{loopback, linkLocal, private, public, circuit} {
+ ma, err := multiaddr.NewMultiaddr(s)
+ if err != nil {
+ t.Fatalf("failed to parse %s: %v", s, err)
+ }
+ input = append(input, ma)
+ }
+
+ announce := true
+ suppress := false
+
+ tests := []struct {
+ name string
+ allowLoopback bool
+ announcePrivate *bool
+ want []string
+ }{
+ {
+ name: "default keeps private addresses so LAN meshes stay reachable",
+ want: []string{private, public, circuit},
+ },
+ {
+ name: "explicit announce private matches the default",
+ announcePrivate: &announce,
+ want: []string{private, public, circuit},
+ },
+ {
+ name: "suppressing private addresses still announces relay paths",
+ announcePrivate: &suppress,
+ want: []string{public, circuit},
+ },
+ {
+ name: "allow loopback publishes everything",
+ allowLoopback: true,
+ want: []string{loopback, linkLocal, private, public, circuit},
+ },
+ {
+ name: "allow loopback combined with suppressed private addresses",
+ allowLoopback: true,
+ announcePrivate: &suppress,
+ want: []string{loopback, linkLocal, public, circuit},
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ n := &SamNode{config: Options{
+ AllowLoopback: tt.allowLoopback,
+ AnnouncePrivateAddrs: tt.announcePrivate,
+ }}
+ got := n.announceFilter(input)
+ if len(got) != len(tt.want) {
+ t.Fatalf("got %v, want %v", got, tt.want)
+ }
+ for i, addr := range got {
+ if addr.String() != tt.want[i] {
+ t.Errorf("addr %d: got %s, want %s", i, addr, tt.want[i])
+ }
+ }
+ })
+ }
+}
+
func TestHandleBannedEvent(t *testing.T) {
revokedCache, _ := lru.New[string, int64](10)
node := &SamNode{
diff --git a/internal/node/options.go b/internal/node/options.go
index cb3d0ee5..6e39d7d7 100644
--- a/internal/node/options.go
+++ b/internal/node/options.go
@@ -33,17 +33,22 @@ const (
// Options holds all configuration options for a SamNode.
type Options struct {
- PrivKey crypto.PrivKey
- ControlPlanePubKey ed25519.PublicKey
- RouterAddrs []multiaddr.Multiaddr
- Store *Store
- MeshID string
- DiscoveryInterval string
- ListenAddrs []string
- EnableRelay bool
- NodeConfig *NodeConfigComplete
- KeyGracePeriod time.Duration
- AllowLoopback bool
+ PrivKey crypto.PrivKey
+ ControlPlanePubKey ed25519.PublicKey
+ RouterAddrs []multiaddr.Multiaddr
+ Store *Store
+ MeshID string
+ DiscoveryInterval string
+ ListenAddrs []string
+ EnableRelay bool
+ NodeConfig *NodeConfigComplete
+ KeyGracePeriod time.Duration
+ AllowLoopback bool
+ // AnnouncePrivateAddrs controls whether RFC1918/ULA addresses are published
+ // to the mesh. Nil means true: private meshes reach each other over exactly
+ // those addresses. Set false on nodes that are only reachable via routers or
+ // public addresses, so peers do not learn the host's internal topology.
+ AnnouncePrivateAddrs *bool
MonitorBootstrap time.Duration
MonitorInterval time.Duration
AutoRelayMinInterval time.Duration
@@ -103,6 +108,10 @@ func (o *Options) Default() {
if len(o.ListenAddrs) == 0 {
o.ListenAddrs = []string{"/ip4/0.0.0.0/udp/5001/quic-v1", "/ip4/0.0.0.0/tcp/5002"}
}
+ if o.AnnouncePrivateAddrs == nil {
+ announce := true
+ o.AnnouncePrivateAddrs = &announce
+ }
if o.RequiredRole == "" {
o.RequiredRole = api.RoleNode
}