[WIP] - Add support for connection gating and address factory

.gitignore

@@ -1,3 +1,4 @@
 .history/
+.idea/
 p2p_poc
 peer_cache.json

client.go

@@ -8,6 +8,8 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"net"
+	"net/http"
 	"os"
 	"sync"
 	"time"
@@ -21,6 +23,7 @@ import (
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/p2p/discovery/mdns"
 	drouting "github.com/libp2p/go-libp2p/p2p/discovery/routing"
+	"github.com/libp2p/go-libp2p/p2p/net/conngater"
 	"github.com/multiformats/go-multiaddr"
 )
 
@@ -70,8 +73,8 @@ func NewClient(config Config) (P2PClient, error) {
 	hostOpts = append(hostOpts, libp2p.Identity(config.PrivateKey))
 
 	// Configure announce addresses if provided (useful for K8s)
+	var announceAddrs []multiaddr.Multiaddr
 	if len(config.AnnounceAddrs) > 0 {
-		var announceAddrs []multiaddr.Multiaddr
 		for _, addrStr := range config.AnnounceAddrs {
 			maddr, err := multiaddr.NewMultiaddr(addrStr)
 			if err != nil {
@@ -87,15 +90,88 @@ func NewClient(config Config) (P2PClient, error) {
 		logger.Infof("Using custom announce addresses: %v", config.AnnounceAddrs)
 	}
 
+	// define address factory to remove all private IPs from being broadcasted
+	addressFactory := func(addrs []multiaddr.Multiaddr) []multiaddr.Multiaddr {
+		var publicAddrs []multiaddr.Multiaddr
+		for _, addr := range addrs {
+			// if IP is not private, add it to the list
+			logger.Infof("address is private? %v", isPrivateIP(config, addr))
+			if !isPrivateIP(config, addr) || config.AllowPrivateIPs {
+				publicAddrs = append(publicAddrs, addr)
+			}
+		}
+		// If a user specified a broadcast IP append it here
+		if len(announceAddrs) > 0 {
+			// here we're appending the external facing multiaddr we created above to the addressFactory so it will be broadcast out when I connect to a bootstrap node.
+			publicAddrs = append(publicAddrs, announceAddrs...)
+		}
+
+		// If we still don't have any advertisable addresses then attempt to grab it from `https://ifconfig.me/ip`
+		if len(publicAddrs) == 0 {
+			// If no public addresses are set, let's attempt to grab it publicly
+			// Ignore errors because we don't care if we can't find it
+			ifconfig, err := GetPublicIP(context.Background())
+			if err != nil {
+				logger.Infof("Failed to get public IP address: %v", err)
+			}
+			if len(ifconfig) > 0 {
+				logger.Infof("Public IP address: %v", ifconfig)
+				addr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ifconfig, config.Port))
+				if err != nil {
+					logger.Infof("Failed to create multiaddr from public IP: %v", err)
+				}
+				if addr != nil {
+					publicAddrs = append(publicAddrs, addr)
+				}
+			}
+		}
+		if len(publicAddrs) > 0 {
+			logger.Infof("Using advertising addresses: %v", publicAddrs[0])
+		}
+		return publicAddrs
+	}
+
+	// Create an IP filter to optionally block private network ranges from being dialed
+	ipFilter, err := conngater.NewBasicConnectionGater(nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// By default, filter private IPs
+	if !config.AllowPrivateIPs {
+		// Add private IP blocks to be filtered out
+		for _, cidr := range []string{
+			"10.0.0.0/8",     // Private network 10.0.0.0 to 10.255.255.255
+			"172.16.0.0/12",  // Private network 172.16.0.0 to 172.31.255.255
+			"192.168.0.0/16", // Private network 192.168.0.0 to 192.168.255.255
+			"127.0.0.0/16",   // Local network
+			"100.64.0.0/10",  // Shared Address Space
+			"169.254.0.0/16", // Link-local addresses
+		} {
+			var ipnet *net.IPNet
+			var err error
+			_, ipnet, err = net.ParseCIDR(cidr)
+			if err != nil {
+				return nil, err
+			}
+			err = ipFilter.BlockSubnet(ipnet)
+			if err != nil {
+				continue
+			}
+		}
+	}
+
 	// Create libp2p host
 	hostOpts = append(hostOpts,
 		libp2p.ListenAddrStrings(
-			"/ip4/0.0.0.0/tcp/0",
-			"/ip6/::/tcp/0",
+			fmt.Sprintf("/ip4/0.0.0.0/tcp/%d", config.Port), // Listen on all interfaces
+			fmt.Sprintf("/ip6/::/tcp/%d", config.Port),
 		),
 		libp2p.EnableNATService(),
 		libp2p.EnableHolePunching(),
 		libp2p.EnableRelay(),
+		libp2p.AddrsFactory(addressFactory),
+		libp2p.ConnectionGater(ipFilter),
 	)
 
 	h, err := libp2p.New(hostOpts...)
@@ -634,3 +710,85 @@ func PrivateKeyFromHex(keyHex string) (crypto.PrivKey, error) {
 
 	return priv, nil
 }
+
+// Function to check if an IP address is private
+func isPrivateIP(config Config, addr multiaddr.Multiaddr) bool {
+	config.Logger.Infof("Multiaddr: %s", addr.String())
+	ipStr, err := extractIPFromMultiaddr(addr)
+	if err != nil {
+		return false
+	}
+	config.Logger.Infof("Extracted IP: %s", ipStr)
+	// Check for IPv6 loopback
+	if ipStr == "::1" {
+		return true
+	}
+
+	ip := net.ParseIP(ipStr)
+	if ip == nil || ip.To4() == nil {
+		return false
+	}
+
+	config.Logger.Infof("Parsed IP: %s", ip.String())
+
+	// Define private IPv4 and IPv6 ranges
+	privateRanges := []*net.IPNet{
+		// IPv4
+		{IP: net.ParseIP("10.0.0.0"), Mask: net.CIDRMask(8, 32)},
+		{IP: net.ParseIP("172.16.0.0"), Mask: net.CIDRMask(12, 32)},
+		{IP: net.ParseIP("192.168.0.0"), Mask: net.CIDRMask(16, 32)},
+		{IP: net.ParseIP("127.0.0.0"), Mask: net.CIDRMask(8, 32)},
+		// IPv6
+		{IP: net.ParseIP("fc00::"), Mask: net.CIDRMask(7, 128)},  // Unique local address
+		{IP: net.ParseIP("fe80::"), Mask: net.CIDRMask(10, 128)}, // Link-local unicast
+	}
+
+	// Check if the IP falls into any of the private ranges or is loopback (::1)
+	for _, r := range privateRanges {
+		if r.Contains(ip) {
+			config.Logger.Infof("Found private IP: %s", ip)
+			return true
+		}
+	}
+
+	return false
+}
+
+// Function to extract IP information from a Multiaddr (supports IPv4 and IPv6)
+func extractIPFromMultiaddr(addr multiaddr.Multiaddr) (string, error) {
+	ip, err := addr.ValueForProtocol(multiaddr.P_IP4)
+	if err == nil && ip != "" {
+		return ip, nil
+	}
+	return addr.ValueForProtocol(multiaddr.P_IP6)
+}
+
+// GetPublicIP fetches the public IP address from ifconfig.me
+func GetPublicIP(ctx context.Context) (string, error) {
+	transport := &http.Transport{
+		DialContext: func(ctx context.Context, _, addr string) (net.Conn, error) {
+			// Force the use of IPv4 by specifying 'tcp4' as the network
+			return (&net.Dialer{}).DialContext(ctx, "tcp4", addr)
+		},
+		TLSHandshakeTimeout: 10 * time.Second,
+	}
+	client := &http.Client{
+		Transport: transport,
+	}
+	req, err := http.NewRequestWithContext(ctx, "GET", "https://ifconfig.me/ip", nil)
+	if err != nil {
+		return "", err
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	return string(body), resp.Body.Close()
+}

config.go

@@ -53,4 +53,10 @@ type Config struct {
 	// Example: []string{"/ip4/203.0.113.1/tcp/4001"}
 	// If not provided, libp2p will automatically detect and announce local addresses.
 	AnnounceAddrs []string
+
+	// AllowPrivateIPs indicates whether to allow connections to peers with private IP addresses.
+	AllowPrivateIPs bool
+
+	// Port is the network port to listen on for incoming connections. If zero, a random port will be chosen.
+	Port int
 }

example/go.mod

@@ -3,8 +3,9 @@ module github.com/ordishs/p2p_poc/example
 go 1.25.1
 
 require (
-	github.com/ordishs/gocore v1.0.81
 	github.com/bsv-blockchain/go-p2p-message-bus v0.0.0
+	github.com/libp2p/go-libp2p v0.43.0
+	github.com/ordishs/gocore v1.0.81
 )
 
 require (
@@ -39,7 +40,6 @@ require (
 	github.com/libp2p/go-buffer-pool v0.1.0 // indirect
 	github.com/libp2p/go-cidranger v1.1.0 // indirect
 	github.com/libp2p/go-flow-metrics v0.3.0 // indirect
-	github.com/libp2p/go-libp2p v0.43.0 // indirect
 	github.com/libp2p/go-libp2p-asn-util v0.4.1 // indirect
 	github.com/libp2p/go-libp2p-kad-dht v0.34.0 // indirect
 	github.com/libp2p/go-libp2p-kbucket v0.7.0 // indirect

example/main.go

@@ -10,15 +10,16 @@ import (
 	"syscall"
 	"time"
 
+	p2p "github.com/bsv-blockchain/go-p2p-message-bus"
 	"github.com/libp2p/go-libp2p/core/crypto"
 	"github.com/ordishs/gocore"
-	p2p "github.com/bsv-blockchain/go-p2p-message-bus"
 )
 
 func main() {
 	name := flag.String("name", "", "Your node name")
 	privateKey := flag.String("key", "", "Private key hex (will generate if not provided)")
 	topics := flag.String("topics", "broadcast_p2p_poc", "Comma-separated list of topics to subscribe to")
+	port := flag.Int("port", 0, "port to listen on (0 for random)")
 	noBroadcast := flag.Bool("no-broadcast", false, "Disable message broadcasting")
 
 	flag.Parse()
@@ -62,10 +63,12 @@ func main() {
 
 	// Create P2P client
 	client, err := p2p.NewClient(p2p.Config{
-		Name:          *name,
-		Logger:        logger,
-		PrivateKey:    privKey,
-		PeerCacheFile: "peer_cache.json", // Enable peer persistence
+		Name:            *name,
+		Logger:          logger,
+		PrivateKey:      privKey,
+		Port:            *port,
+		AllowPrivateIPs: false,
+		PeerCacheFile:   "peer_cache.json", // Enable peer persistence
 	})
 	if err != nil {
 		logger.Fatalf("Failed to create P2P client: %v", err)