From ea06183f90d5d0f2cb86808934777ae9e5293783 Mon Sep 17 00:00:00 2001 From: b00f Date: Sat, 4 Nov 2023 21:34:43 +0800 Subject: [PATCH] feat(network): adding public address to factory (#795) --- config/config.go | 3 +- config/config_test.go | 2 + config/example_config.toml | 19 +++- genesis/genesis.go | 13 +++ genesis/genesis_test.go | 23 +++-- network/config.go | 50 +++++---- network/config_test.go | 4 + network/dht.go | 2 +- network/gater.go | 86 ++++++++++++++++ network/gater_test.go | 1 + network/mock.go | 14 +-- network/network.go | 114 +++++++++------------ network/network_test.go | 21 ++-- network/peermgr.go | 2 +- network/utils.go | 129 ++++++++++++++++++++++-- network/utils_test.go | 201 +++++++++++++++++++++++++++++++++++++ tests/main_test.go | 2 +- 17 files changed, 557 insertions(+), 129 deletions(-) create mode 100644 network/gater.go create mode 100644 network/gater_test.go create mode 100644 network/utils_test.go diff --git a/config/config.go b/config/config.go index 02fd99f9a..2f05a4fa0 100644 --- a/config/config.go +++ b/config/config.go @@ -19,7 +19,7 @@ import ( "github.com/pactus-project/pactus/www/grpc" "github.com/pactus-project/pactus/www/http" "github.com/pactus-project/pactus/www/nanomsg" - toml "github.com/pelletier/go-toml" + "github.com/pelletier/go-toml" ) //go:embed example_config.toml @@ -44,6 +44,7 @@ type NodeConfig struct { } func DefaultNodeConfig() *NodeConfig { + // TODO: We should have default config per network: Testnet, Mainnet. return &NodeConfig{ NumValidators: 7, } diff --git a/config/config_test.go b/config/config_test.go index cf211524a..a6909ada8 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -27,6 +27,7 @@ func TestSaveTestnetConfig(t *testing.T) { assert.NoError(t, err) assert.NoError(t, conf.BasicCheck()) + assert.Equal(t, conf.Network.DefaultPort, 21777) } func TestSaveLocalnetConfig(t *testing.T) { @@ -39,6 +40,7 @@ func TestSaveLocalnetConfig(t *testing.T) { assert.NoError(t, conf.BasicCheck()) assert.Empty(t, conf.Network.Listens) assert.Empty(t, conf.Network.RelayAddrs) + assert.Equal(t, conf.Network.DefaultPort, 21777) } func TestLoadFromFile(t *testing.T) { diff --git a/config/example_config.toml b/config/example_config.toml index 4ddafb915..9f69687a9 100644 --- a/config/example_config.toml +++ b/config/example_config.toml @@ -24,6 +24,15 @@ # `network_key` specifies the private key filename to use for node authentication and encryption in the p2p protocol. ## network_key = "network_key" + # `public_address` is a list of addresses that are public and accessible to other nodes. + # If it is empty, the node attempts to automatically detect its public IP addresses. + # It is recommended to set the public address if available. + # Example addresses: + # - "/ip4/1.2.3.4/tcp/21888" + # - "/ip6/2606:4700:4700::1111/udp/21888" + # - "/dnsaddr/my-server.amazonaws.com/tcp/21888" + ## public_address = [] + # `listens` specifies the addresses and ports where the node will listen for incoming connections from other nodes. ## listens = ["/ip4/0.0.0.0/tcp/21888", "/ip6/::/tcp/21888", "/ip4/0.0.0.0/udp/21888/quic-v1", "/ip6/::/udp/21888/quic-v1"] @@ -58,15 +67,17 @@ # Default is false. ## enable_mdns = false - # `enable_metrics` if enabled, it provides network metrics for the Prometheus software. + # `enable_metrics` provides the network metrics for the Prometheus software. # Default is false. ## enable_metrics = false - # `private_network` if enabled, connects to nodes in the private network. + # `force_private_network` forces the connection to nodes within a private network. + # A private network is a computer network that uses private addresses. + # Read more about private networks here: https://en.wikipedia.org/wiki/Private_network # Default is false. - ## private_network = false + ## force_private_network = false - # `bootstrapper` if enabled, it runs the node in bootstrap mode. + # `bootstrapper` runs the node in bootstrap mode. # Default is false. ## bootstrapper = false diff --git a/genesis/genesis.go b/genesis/genesis.go index a1e6b2f6c..b189eb30a 100644 --- a/genesis/genesis.go +++ b/genesis/genesis.go @@ -200,3 +200,16 @@ func (gen *Genesis) NetworkName() string { return "unknown" } } + +func (gen *Genesis) DefaultPort() int { + switch gen.ChainType() { + case Mainnet: + return 21888 + case Testnet: + return 21777 + case Localnet: + return 21666 + default: + return 0 + } +} diff --git a/genesis/genesis_test.go b/genesis/genesis_test.go index f0d7e81e5..76f94f6c1 100644 --- a/genesis/genesis_test.go +++ b/genesis/genesis_test.go @@ -48,19 +48,21 @@ func TestMarshaling(t *testing.T) { } func TestGenesisTestNet(t *testing.T) { - g := genesis.TestnetGenesis() - assert.Equal(t, len(g.Validators()), 4) - assert.Equal(t, len(g.Accounts()), 1) + gen := genesis.TestnetGenesis() + assert.Equal(t, len(gen.Validators()), 4) + assert.Equal(t, len(gen.Accounts()), 1) - assert.Equal(t, g.Accounts()[crypto.TreasuryAddress].Balance(), int64(21e15)) + assert.Equal(t, gen.Accounts()[crypto.TreasuryAddress].Balance(), int64(21e15)) genTime, _ := time.Parse("2006-01-02", "2023-10-15") expected, _ := hash.FromString("da602b28f75902c35e3bafeb5733a686c94d5508c92aae68cbd9b37d81cfccf4") - assert.Equal(t, g.Hash(), expected) - assert.Equal(t, g.GenesisTime(), genTime) - assert.Equal(t, g.Params().BondInterval, uint32(120)) - assert.Equal(t, g.ChainType(), genesis.Testnet) - assert.Equal(t, g.TotalSupply(), int64(42*1e15)) + assert.Equal(t, gen.Hash(), expected) + assert.Equal(t, gen.GenesisTime(), genTime) + assert.Equal(t, gen.Params().BondInterval, uint32(120)) + assert.Equal(t, gen.ChainType(), genesis.Testnet) + assert.Equal(t, gen.TotalSupply(), int64(42*1e15)) + assert.Equal(t, gen.NetworkName(), "pactus-testnet") + assert.Equal(t, gen.DefaultPort(), 21777) } func TestCheckGenesisAccountAndValidator(t *testing.T) { @@ -85,4 +87,7 @@ func TestCheckGenesisAccountAndValidator(t *testing.T) { for i, val := range gen.Validators() { assert.Equal(t, val.Hash(), vals[i].Hash()) } + + assert.Equal(t, gen.NetworkName(), "pactus-localnet") + assert.Equal(t, gen.DefaultPort(), 21666) } diff --git a/network/config.go b/network/config.go index 8fedbb10f..cbfd9a482 100644 --- a/network/config.go +++ b/network/config.go @@ -8,18 +8,20 @@ import ( ) type Config struct { - NetworkKey string `toml:"network_key"` - Listens []string `toml:"listens"` - RelayAddrs []string `toml:"relay_addresses"` - BootstrapAddrs []string `toml:"bootstrap_addresses"` - MinConns int `toml:"min_connections"` - MaxConns int `toml:"max_connections"` - EnableNAT bool `toml:"enable_nat"` - EnableRelay bool `toml:"enable_relay"` - EnableMdns bool `toml:"enable_mdns"` - EnableMetrics bool `toml:"enable_metrics"` - PrivateNetwork bool `toml:"private_network"` - Bootstrapper bool `toml:"bootstrapper"` + NetworkKey string `toml:"network_key"` + PublicAddress []string `toml:"public_address"` + Listens []string `toml:"listens"` + RelayAddrs []string `toml:"relay_addresses"` + BootstrapAddrs []string `toml:"bootstrap_addresses"` + MinConns int `toml:"min_connections"` + MaxConns int `toml:"max_connections"` + EnableNAT bool `toml:"enable_nat"` + EnableRelay bool `toml:"enable_relay"` + EnableMdns bool `toml:"enable_mdns"` + EnableMetrics bool `toml:"enable_metrics"` + ForcePrivateNetwork bool `toml:"force_private_network"` + Bootstrapper bool `toml:"bootstrapper"` // TODO: detect it automatically + DefaultPort int `toml:"-"` } func DefaultConfig() *Config { @@ -47,16 +49,17 @@ func DefaultConfig() *Config { "/ip4/0.0.0.0/tcp/21888", "/ip6/::/tcp/21888", "/ip4/0.0.0.0/udp/21888/quic-v1", "/ip6/::/udp/21888/quic-v1", }, - RelayAddrs: []string{}, - BootstrapAddrs: bootstrapAddrs, - MinConns: 8, - MaxConns: 16, - EnableNAT: true, - EnableRelay: false, - EnableMdns: false, - EnableMetrics: false, - PrivateNetwork: false, - Bootstrapper: false, + RelayAddrs: []string{}, + BootstrapAddrs: bootstrapAddrs, + MinConns: 8, + MaxConns: 16, + EnableNAT: true, + EnableRelay: false, + EnableMdns: false, + EnableMetrics: false, + ForcePrivateNetwork: false, + Bootstrapper: false, + DefaultPort: 21777, } } @@ -77,6 +80,9 @@ func (conf *Config) BasicCheck() error { return errors.Errorf(errors.ErrInvalidConfig, "at least one relay address should be defined") } } + if err := validateAddresses(conf.PublicAddress); err != nil { + return err + } if err := validateAddresses(conf.RelayAddrs); err != nil { return err } diff --git a/network/config_test.go b/network/config_test.go index c230a810f..005b49537 100644 --- a/network/config_test.go +++ b/network/config_test.go @@ -23,6 +23,10 @@ func TestDefaultConfigCheck(t *testing.T) { conf.Listens = []string{"/ip4"} assert.Error(t, conf.BasicCheck()) + conf = DefaultConfig() + conf.PublicAddress = []string{"/ip4"} + assert.Error(t, conf.BasicCheck()) + conf = DefaultConfig() conf.RelayAddrs = []string{"/ip4"} assert.Error(t, conf.BasicCheck()) diff --git a/network/dht.go b/network/dht.go index b065f5739..8abc242f4 100644 --- a/network/dht.go +++ b/network/dht.go @@ -23,7 +23,7 @@ func newDHTService(ctx context.Context, host lp2phost.Host, protocolID lp2pcore. if conf.Bootstrapper { mode = lp2pdht.ModeServer } - bootstrapAddrs := PeerAddrsToAddrInfo(conf.BootstrapAddrs) + bootstrapAddrs, _ := MakeAddrInfos(conf.BootstrapAddrs) opts := []lp2pdht.Option{ lp2pdht.Mode(mode), lp2pdht.ProtocolPrefix(protocolID), diff --git a/network/gater.go b/network/gater.go new file mode 100644 index 000000000..87fb6a9f7 --- /dev/null +++ b/network/gater.go @@ -0,0 +1,86 @@ +package network + +import ( + lp2pconnmgr "github.com/libp2p/go-libp2p/core/connmgr" + lp2pcontrol "github.com/libp2p/go-libp2p/core/control" + lp2pnetwork "github.com/libp2p/go-libp2p/core/network" + lp2ppeer "github.com/libp2p/go-libp2p/core/peer" + lp2pconngater "github.com/libp2p/go-libp2p/p2p/net/conngater" + "github.com/multiformats/go-multiaddr" + "github.com/pactus-project/pactus/util/logger" +) + +var _ lp2pconnmgr.ConnectionGater = &ConnectionGater{} + +type ConnectionGater struct { + *lp2pconngater.BasicConnectionGater + + logger *logger.SubLogger +} + +func NewConnectionGater(conf *Config) (*ConnectionGater, error) { + connGater, err := lp2pconngater.NewBasicConnectionGater(nil) + if err != nil { + return nil, err + } + + if !conf.ForcePrivateNetwork { + privateSubnets := PrivateSubnets() + for _, sn := range privateSubnets { + err := connGater.BlockSubnet(sn) + if err != nil { + return nil, LibP2PError{Err: err} + } + } + } + + return &ConnectionGater{ + BasicConnectionGater: connGater, + }, nil +} + +func (g *ConnectionGater) SetLogger(log *logger.SubLogger) { + g.logger = log +} + +func (g *ConnectionGater) InterceptPeerDial(p lp2ppeer.ID) bool { + allow := g.BasicConnectionGater.InterceptPeerDial(p) + if !allow { + g.logger.Debug("InterceptPeerDial not allowed", "p") + } + + return allow +} + +func (g *ConnectionGater) InterceptAddrDial(p lp2ppeer.ID, ma multiaddr.Multiaddr) bool { + allow := g.BasicConnectionGater.InterceptAddrDial(p, ma) + if !allow { + g.logger.Debug("InterceptAddrDial not allowed", "p", p, "ma", ma.String()) + } + + return allow +} + +func (g *ConnectionGater) InterceptAccept(cma lp2pnetwork.ConnMultiaddrs) bool { + allow := g.BasicConnectionGater.InterceptAccept(cma) + if !allow { + g.logger.Debug("InterceptAccept not allowed") + } + + return allow +} + +func (g *ConnectionGater) InterceptSecured(dir lp2pnetwork.Direction, p lp2ppeer.ID, + cma lp2pnetwork.ConnMultiaddrs, +) bool { + allow := g.BasicConnectionGater.InterceptSecured(dir, p, cma) + if !allow { + g.logger.Debug("InterceptSecured not allowed", "p", p) + } + + return allow +} + +func (g *ConnectionGater) InterceptUpgraded(con lp2pnetwork.Conn) (bool, lp2pcontrol.DisconnectReason) { + return g.BasicConnectionGater.InterceptUpgraded(con) +} diff --git a/network/gater_test.go b/network/gater_test.go new file mode 100644 index 000000000..1ae2e9d50 --- /dev/null +++ b/network/gater_test.go @@ -0,0 +1 @@ +package network diff --git a/network/mock.go b/network/mock.go index a58b53404..d1ecc8d26 100644 --- a/network/mock.go +++ b/network/mock.go @@ -5,7 +5,7 @@ import ( "io" lp2pcore "github.com/libp2p/go-libp2p/core" - "github.com/libp2p/go-libp2p/core/peer" + lp2ppeer "github.com/libp2p/go-libp2p/core/peer" "github.com/pactus-project/pactus/util/testsuite" ) @@ -21,12 +21,12 @@ type MockNetwork struct { PublishCh chan PublishData EventCh chan Event - ID peer.ID + ID lp2ppeer.ID OtherNets []*MockNetwork SendError error } -func MockingNetwork(ts *testsuite.TestSuite, id peer.ID) *MockNetwork { +func MockingNetwork(ts *testsuite.TestSuite, id lp2ppeer.ID) *MockNetwork { return &MockNetwork{ TestSuite: ts, PublishCh: make(chan PublishData, 100), @@ -55,7 +55,7 @@ func (mock *MockNetwork) JoinConsensusTopic() error { return nil } -func (mock *MockNetwork) SelfID() peer.ID { +func (mock *MockNetwork) SelfID() lp2ppeer.ID { return mock.ID } @@ -78,7 +78,7 @@ func (mock *MockNetwork) Broadcast(data []byte, _ TopicID) error { return nil } -func (mock *MockNetwork) SendToOthers(data []byte, target *peer.ID) { +func (mock *MockNetwork) SendToOthers(data []byte, target *lp2ppeer.ID) { for _, net := range mock.OtherNets { if target == nil { // Broadcast message @@ -99,7 +99,7 @@ func (mock *MockNetwork) SendToOthers(data []byte, target *peer.ID) { } } -func (mock *MockNetwork) CloseConnection(pid peer.ID) { +func (mock *MockNetwork) CloseConnection(pid lp2ppeer.ID) { for i, net := range mock.OtherNets { if net.ID == pid { mock.OtherNets = append(mock.OtherNets[:i], mock.OtherNets[i+1:]...) @@ -107,7 +107,7 @@ func (mock *MockNetwork) CloseConnection(pid peer.ID) { } } -func (mock *MockNetwork) IsClosed(pid peer.ID) bool { +func (mock *MockNetwork) IsClosed(pid lp2ppeer.ID) bool { for _, net := range mock.OtherNets { if net.ID == pid { return false diff --git a/network/network.go b/network/network.go index 35a42d8ed..4f65d4545 100644 --- a/network/network.go +++ b/network/network.go @@ -13,9 +13,8 @@ import ( lp2phost "github.com/libp2p/go-libp2p/core/host" lp2ppeer "github.com/libp2p/go-libp2p/core/peer" lp2prcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" - lp2pconngater "github.com/libp2p/go-libp2p/p2p/net/conngater" lp2pconnmgr "github.com/libp2p/go-libp2p/p2p/net/connmgr" - ma "github.com/multiformats/go-multiaddr" + "github.com/multiformats/go-multiaddr" "github.com/pactus-project/pactus/util" "github.com/pactus-project/pactus/util/logger" "github.com/pactus-project/pactus/version" @@ -37,6 +36,7 @@ type network struct { mdns *mdnsService dht *dhtService peerMgr *peerMgr + connGater *ConnectionGater stream *streamService gossip *gossipService notifee *NotifeeService @@ -88,45 +88,24 @@ func newNetwork(networkName string, conf *Config, opts []lp2p.Option) (*network, return nil, LibP2PError{Err: err} } + rcMgrOpt := []lp2prcmgr.Option{} if conf.EnableMetrics { - lp2prcmgr.MustRegisterWith(prometheus.DefaultRegisterer) - } + str, err := lp2prcmgr.NewStatsTraceReporter() + if err != nil { + return nil, LibP2PError{Err: err} + } - str, err := lp2prcmgr.NewStatsTraceReporter() - if err != nil { - return nil, LibP2PError{Err: err} + lp2prcmgr.MustRegisterWith(prometheus.DefaultRegisterer) + rcMgrOpt = append(rcMgrOpt, lp2prcmgr.WithTraceReporter(str)) + } else { + rcMgrOpt = append(rcMgrOpt, lp2prcmgr.WithMetricsDisabled()) + opts = append(opts, lp2p.DisableMetrics()) } - // - // This is crazy! - // Do they even know how to configure it properly?! - // - maxConns := conf.MaxConns - minConns := conf.MinConns - limit := lp2prcmgr.DefaultLimits - limit.SystemBaseLimit.ConnsInbound = LogScale(maxConns) - limit.SystemBaseLimit.Conns = LogScale(2 * maxConns) - limit.SystemBaseLimit.StreamsInbound = LogScale(maxConns) - limit.SystemBaseLimit.Streams = LogScale(2 * maxConns) - - limit.ServiceLimitIncrease.ConnsInbound = LogScale(minConns) - limit.ServiceLimitIncrease.Conns = LogScale(2 * minConns) - limit.ServiceLimitIncrease.StreamsInbound = LogScale(minConns) - limit.ServiceLimitIncrease.Streams = LogScale(2 * minConns) - - limit.TransientBaseLimit.ConnsInbound = LogScale(maxConns / 2) - limit.TransientBaseLimit.Conns = LogScale(2 * maxConns / 2) - limit.TransientBaseLimit.StreamsInbound = LogScale(maxConns / 2) - limit.TransientBaseLimit.Streams = LogScale(2 * maxConns / 2) - - limit.TransientLimitIncrease.ConnsInbound = LogScale(minConns / 2) - limit.TransientLimitIncrease.Conns = LogScale(2 * minConns / 2) - limit.TransientLimitIncrease.StreamsInbound = LogScale(minConns / 2) - limit.TransientLimitIncrease.Streams = LogScale(2 * minConns / 2) - + limit := MakeScalingLimitConfig(conf.MinConns, conf.MaxConns) resMgr, err := lp2prcmgr.NewResourceManager( lp2prcmgr.NewFixedLimiter(limit.AutoScale()), - lp2prcmgr.WithTraceReporter(str), + rcMgrOpt..., ) if err != nil { return nil, LibP2PError{Err: err} @@ -149,10 +128,6 @@ func newNetwork(networkName string, conf *Config, opts []lp2p.Option) (*network, lp2p.ConnectionManager(connMgr), ) - if !conf.EnableMetrics { - opts = append(opts, lp2p.DisableMetrics()) - } - if conf.EnableNAT { opts = append(opts, lp2p.EnableNATService(), @@ -160,10 +135,10 @@ func newNetwork(networkName string, conf *Config, opts []lp2p.Option) (*network, ) } - relayAddrs := []ma.Multiaddr{} + relayAddrs := []multiaddr.Multiaddr{} if conf.EnableRelay { for _, s := range conf.RelayAddrs { - addr, err := ma.NewMultiaddr(s) + addr, err := multiaddr.NewMultiaddr(s) if err != nil { return nil, LibP2PError{Err: err} } @@ -188,35 +163,44 @@ func newNetwork(networkName string, conf *Config, opts []lp2p.Option) (*network, // TODO: should include relay addresses privateSubnets := PrivateSubnets() - privateFilters := SubnetsToFilters(privateSubnets, ma.ActionDeny) - addrFactory := lp2p.AddrsFactory(func(as []ma.Multiaddr) []ma.Multiaddr { - addrs := []ma.Multiaddr{} - for _, addr := range as { - if conf.PrivateNetwork || !privateFilters.AddrBlocked(addr) { + privateFilters := SubnetsToFilters(privateSubnets, multiaddr.ActionDeny) + publicAddrs, _ := MakeMultiAddrs(conf.PublicAddress) + if len(publicAddrs) == 0 { + addIP := func(detector func() (string, bool)) { + ip, ok := detector() + if ok { + ma, err := IPToMultiAddr(ip, conf.DefaultPort) + if err == nil { + logger.Debug("ip address is private", "ip", ip) + return + } + if !privateFilters.AddrBlocked(ma) { + publicAddrs = append(publicAddrs, ma) + } + } + } + + addIP(DetectPublicIPv4) + addIP(DetectPublicIPv6) + } + + addrFactory := lp2p.AddrsFactory(func(mas []multiaddr.Multiaddr) []multiaddr.Multiaddr { + addrs := []multiaddr.Multiaddr{} + for _, addr := range mas { + if conf.ForcePrivateNetwork || !privateFilters.AddrBlocked(addr) { addrs = append(addrs, addr) - } else { - // TODO: remove me later - logger.Debug("private ip filtered", "ip", conf.PrivateNetwork) } } + addrs = append(addrs, publicAddrs...) return addrs }) + opts = append(opts, addrFactory) - if !conf.PrivateNetwork { - connGater, err := lp2pconngater.NewBasicConnectionGater(nil) - if err != nil { - return nil, LibP2PError{Err: err} - } - for _, sn := range privateSubnets { - err := connGater.BlockSubnet(sn) - if err != nil { - return nil, LibP2PError{Err: err} - } - } - opts = append(opts, lp2p.ConnectionGater(connGater)) + connGater, err := NewConnectionGater(conf) + if err != nil { + return nil, LibP2PError{Err: err} } - - opts = append(opts, addrFactory) + opts = append(opts, lp2p.ConnectionGater(connGater)) host, err := lp2p.New(opts...) if err != nil { @@ -231,16 +215,18 @@ func newNetwork(networkName string, conf *Config, opts []lp2p.Option) (*network, name: networkName, config: conf, host: host, + connGater: connGater, eventChannel: make(chan Event, 100), } n.logger = logger.NewSubLogger("_network", n) + connGater.SetLogger(n.logger) if conf.EnableMdns { n.mdns = newMdnsService(ctx, n.host, n.logger) } - kadProtocolID := lp2pcore.ProtocolID(fmt.Sprintf("/%s/gossip/v1", n.name)) + kadProtocolID := lp2pcore.ProtocolID(fmt.Sprintf("/%s/gossip/v1", n.name)) // TODO: better name? streamProtocolID := lp2pcore.ProtocolID(fmt.Sprintf("/%s/stream/v1", n.name)) n.dht = newDHTService(n.ctx, n.host, kadProtocolID, conf, n.logger) diff --git a/network/network_test.go b/network/network_test.go index 85f0c77a0..c8f9fc310 100644 --- a/network/network_test.go +++ b/network/network_test.go @@ -56,15 +56,15 @@ func makeTestNetwork(t *testing.T, conf *Config, opts []lp2p.Option) *network { func testConfig() *Config { return &Config{ - Listens: []string{}, - NetworkKey: util.TempFilePath(), - BootstrapAddrs: []string{}, - MinConns: 4, - MaxConns: 8, - EnableNAT: false, - EnableRelay: false, - EnableMdns: false, - PrivateNetwork: true, + Listens: []string{}, + NetworkKey: util.TempFilePath(), + BootstrapAddrs: []string{}, + MinConns: 4, + MaxConns: 8, + EnableNAT: false, + EnableRelay: false, + EnableMdns: false, + ForcePrivateNetwork: true, } } @@ -188,6 +188,7 @@ func TestNetwork(t *testing.T) { confM.EnableRelay = true confM.RelayAddrs = relayAddrs confM.BootstrapAddrs = bootstrapAddresses + confM.ForcePrivateNetwork = true confM.Listens = []string{ "/ip4/127.0.0.1/tcp/0", } @@ -202,6 +203,7 @@ func TestNetwork(t *testing.T) { confN.EnableRelay = true confN.RelayAddrs = relayAddrs confN.BootstrapAddrs = bootstrapAddresses + confN.ForcePrivateNetwork = true confN.Listens = []string{ "/ip4/127.0.0.1/tcp/0", } @@ -215,6 +217,7 @@ func TestNetwork(t *testing.T) { confX := testConfig() confX.EnableRelay = false confX.BootstrapAddrs = bootstrapAddresses + confX.ForcePrivateNetwork = true confX.Listens = []string{ "/ip4/127.0.0.1/tcp/0", } diff --git a/network/peermgr.go b/network/peermgr.go index 6af05f63b..51030e0b8 100644 --- a/network/peermgr.go +++ b/network/peermgr.go @@ -37,7 +37,7 @@ type peerMgr struct { func newPeerMgr(ctx context.Context, h lp2phost.Host, dht *lp2pdht.IpfsDHT, conf *Config, log *logger.SubLogger, ) *peerMgr { - bootstrapAddrs := PeerAddrsToAddrInfo(conf.BootstrapAddrs) + bootstrapAddrs, _ := MakeAddrInfos(conf.BootstrapAddrs) b := &peerMgr{ ctx: ctx, bootstrapAddrs: bootstrapAddrs, diff --git a/network/utils.go b/network/utils.go index fe37fa74b..c241439b3 100644 --- a/network/utils.go +++ b/network/utils.go @@ -2,6 +2,7 @@ package network import ( "context" + "fmt" "math/bits" "net" "time" @@ -9,30 +10,64 @@ import ( lp2phost "github.com/libp2p/go-libp2p/core/host" lp2pnetwork "github.com/libp2p/go-libp2p/core/network" lp2ppeer "github.com/libp2p/go-libp2p/core/peer" + lp2prcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" "github.com/multiformats/go-multiaddr" "github.com/pactus-project/pactus/util/logger" ) -// PeerAddrsToAddrInfo converts a slice of string peer addresses -// to AddrInfo. -func PeerAddrsToAddrInfo(addrs []string) []lp2ppeer.AddrInfo { +// MakeMultiAddrs converts a slice of string peer addresses to MultiAddress. +func MakeMultiAddrs(addrs []string) ([]multiaddr.Multiaddr, error) { + mas := make([]multiaddr.Multiaddr, 0, len(addrs)) + for _, addr := range addrs { + ma, err := multiaddr.NewMultiaddr(addr) + if err != nil { + return nil, err + } + mas = append(mas, ma) + } + return mas, nil +} + +// MakeAddrInfos converts a slice of string peer addresses to AddrInfo. +func MakeAddrInfos(addrs []string) ([]lp2ppeer.AddrInfo, error) { pis := make([]lp2ppeer.AddrInfo, 0, len(addrs)) for _, addr := range addrs { - pinfo, _ := MakeAddressInfo(addr) - if pinfo != nil { - pis = append(pis, *pinfo) + pinfo, err := MakeAddressInfo(addr) + if err != nil { + return nil, err } + pis = append(pis, *pinfo) } - return pis + return pis, nil } // MakeAddressInfo from Multi-address string. func MakeAddressInfo(addr string) (*lp2ppeer.AddrInfo, error) { - maddr, err := multiaddr.NewMultiaddr(addr) + ma, err := multiaddr.NewMultiaddr(addr) + if err != nil { + return nil, err + } + return lp2ppeer.AddrInfoFromP2pAddr(ma) +} + +func IPToMultiAddr(ip string, port int) (multiaddr.Multiaddr, error) { + ipParsed := net.ParseIP(ip) + if ipParsed == nil { + return nil, fmt.Errorf("invalid IP address: %s", ip) + } + + var addr string + if ipParsed.To4() != nil { + addr = fmt.Sprintf("/ip4/%s/tcp/%d", ip, port) + } else { + addr = fmt.Sprintf("/ip6/%s/tcp/%d", ip, port) + } + ma, err := multiaddr.NewMultiaddr(addr) if err != nil { return nil, err } - return lp2ppeer.AddrInfoFromP2pAddr(maddr) + + return ma, nil } // HasPID checks if a peer ID exists in a list of peer IDs. @@ -60,8 +95,10 @@ func ConnectAsync(ctx context.Context, h lp2phost.Host, addrInfo lp2ppeer.AddrIn }() } +// LogScale computes 2^⌈log₂(val)⌉, where ⌈x⌉ represents the ceiling of x. +// For more information, refer to: https://en.wikipedia.org/wiki/Logarithmic_scale func LogScale(val int) int { - bitlen := bits.Len(uint(val)) + bitlen := bits.Len(uint(val - 1)) return 1 << bitlen } @@ -107,3 +144,75 @@ func SubnetsToFilters(subnets []*net.IPNet, action multiaddr.Action) *multiaddr. return filters } + +func MakeScalingLimitConfig(minConns, maxConns int) lp2prcmgr.ScalingLimitConfig { + limit := lp2prcmgr.DefaultLimits + + limit.SystemBaseLimit.ConnsInbound = LogScale(maxConns) + limit.SystemBaseLimit.Conns = LogScale(2 * maxConns) + limit.SystemBaseLimit.StreamsInbound = LogScale(maxConns) + limit.SystemBaseLimit.Streams = LogScale(2 * maxConns) + + limit.ServiceLimitIncrease.ConnsInbound = LogScale(minConns) + limit.ServiceLimitIncrease.Conns = LogScale(2 * minConns) + limit.ServiceLimitIncrease.StreamsInbound = LogScale(minConns) + limit.ServiceLimitIncrease.Streams = LogScale(2 * minConns) + + limit.TransientBaseLimit.ConnsInbound = LogScale(maxConns / 2) + limit.TransientBaseLimit.Conns = LogScale(2 * maxConns / 2) + limit.TransientBaseLimit.StreamsInbound = LogScale(maxConns / 2) + limit.TransientBaseLimit.Streams = LogScale(2 * maxConns / 2) + + limit.TransientLimitIncrease.ConnsInbound = LogScale(minConns / 2) + limit.TransientLimitIncrease.Conns = LogScale(2 * minConns / 2) + limit.TransientLimitIncrease.StreamsInbound = LogScale(minConns / 2) + limit.TransientLimitIncrease.Streams = LogScale(2 * minConns / 2) + + return limit +} + +// DetectPublicIPv4 returns the public IPv4 address of the local machine by dialing a list of specific IP addresses. +func DetectPublicIPv4() (string, bool) { + ips := []string{ + "8.8.8.8", // Google + "1.1.1.1", // Cloudflare + "9.9.9.9", // Quad9 + "208.67.222.222", // OpenDNS + } + + for _, ip := range ips { + conn, err := net.Dial("udp", ip+":53") // Use a UDP connection to avoid blocking + if err == nil { + conn.Close() + + localAddr := conn.LocalAddr().(*net.UDPAddr) + return localAddr.IP.String(), true + } + } + + // If all attempts failed, return false + return "", false +} + +// DetectPublicIPv6 returns the public IPv6 address of the local machine by dialing a list of specific IPv6 addresses. +func DetectPublicIPv6() (string, bool) { + ips := []string{ + "2001:4860:4860::8888", // Google + "2620:0:ccc::2", // OpenDNS + "2620:fe::fe", // Quad9 + "2606:4700:4700::1111", // Cloudflare + } + + for _, ip := range ips { + conn, err := net.Dial("udp", "["+ip+"]:53") // Use a UDP connection to avoid blocking + if err == nil { + conn.Close() + + localAddr := conn.LocalAddr().(*net.UDPAddr) + return localAddr.IP.String(), true + } + } + + // If all attempts failed, return false + return "", false +} diff --git a/network/utils_test.go b/network/utils_test.go new file mode 100644 index 000000000..b5be150f7 --- /dev/null +++ b/network/utils_test.go @@ -0,0 +1,201 @@ +package network + +import ( + "fmt" + "testing" + + lp2ppeer "github.com/libp2p/go-libp2p/core/peer" + "github.com/multiformats/go-multiaddr" + "github.com/stretchr/testify/assert" +) + +func TestMakeMultiAddrs(t *testing.T) { + testCases := []struct { + name string + inputAddrs []string + expected []multiaddr.Multiaddr + }{ + { + inputAddrs: []string{ + "/ip4/127.0.0.1/tcp/1234", + "/ip6/::1/tcp/5678/", + "/dns4/example.com", + }, + expected: []multiaddr.Multiaddr{ + multiaddr.Cast([]byte{0x04, 0x7f, 0x00, 0x00, 0x01, 0x06, 0x04, 0xd2}), + multiaddr.Cast([]byte{ + 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x06, 0x16, 0x2e, + }), + multiaddr.Cast([]byte{0x36, 0x0b, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d}), + }, + }, + { + inputAddrs: []string{ + "invalid_address", + }, + expected: nil, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + actualPis, actualError := MakeMultiAddrs(tc.inputAddrs) + + if tc.expected != nil { + assert.Equal(t, actualPis, tc.expected) + assert.NoError(t, actualError) + } else { + assert.Error(t, actualError) + assert.Nil(t, actualPis) + } + }) + } +} + +func TestMakeAddrInfos(t *testing.T) { + pid, _ := lp2ppeer.Decode("12D3KooWCwQZt8UriVXobQHPXPR8m83eceXVoeT6brPNiBHomebc") + testCases := []struct { + name string + inputAddrs []string + expectedPis []lp2ppeer.AddrInfo + }{ + { + inputAddrs: []string{ + "/ip4/127.0.0.1/tcp/1234/p2p/12D3KooWCwQZt8UriVXobQHPXPR8m83eceXVoeT6brPNiBHomebc", + "/ip6/::1/tcp/5678/p2p/12D3KooWCwQZt8UriVXobQHPXPR8m83eceXVoeT6brPNiBHomebc", + "/dns4/example.com/tcp/4001/p2p/12D3KooWCwQZt8UriVXobQHPXPR8m83eceXVoeT6brPNiBHomebc", + }, + expectedPis: []lp2ppeer.AddrInfo{ + { + ID: pid, + Addrs: []multiaddr.Multiaddr{ + multiaddr.StringCast("/ip4/127.0.0.1/tcp/1234"), + }, + }, + { + ID: pid, + Addrs: []multiaddr.Multiaddr{ + multiaddr.StringCast("/ip6/::1/tcp/5678"), + }, + }, + { + ID: pid, + Addrs: []multiaddr.Multiaddr{ + multiaddr.StringCast("/dns4/example.com/tcp/4001"), + }, + }, + }, + }, + { + inputAddrs: []string{ + "/ip4/127.0.0.1/tcp/1234", // No peer id + }, + expectedPis: nil, + }, + { + inputAddrs: []string{ + "invalid_address", + }, + expectedPis: nil, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + actualPis, actualError := MakeAddrInfos(tc.inputAddrs) + + if tc.expectedPis != nil { + assert.Equal(t, actualPis, tc.expectedPis) + assert.NoError(t, actualError) + } else { + assert.Error(t, actualError) + assert.Nil(t, actualPis) + } + }) + } +} + +func TestIPToMultiAddr(t *testing.T) { + testCases := []struct { + ip string + port int + expected string + }{ + {"127.0.0.1", 8080, "/ip4/127.0.0.1/tcp/8080"}, + {"192.168.1.1", 1234, "/ip4/192.168.1.1/tcp/1234"}, + {"::1", 80, "/ip6/::1/tcp/80"}, + {"invalid_ip", 80, ""}, + } + + for _, testCase := range testCases { + t.Run(testCase.expected, func(t *testing.T) { + ma, err := IPToMultiAddr(testCase.ip, testCase.port) + if testCase.expected != "" { + assert.NoError(t, err) + assert.Equal(t, testCase.expected, ma.String()) + } else { + assert.Error(t, err) + } + }) + } +} + +func TestLogScale(t *testing.T) { + testCases := []struct { + input int + expected int + }{ + {1, 1}, + {2, 2}, + {3, 4}, + {7, 8}, + {8, 8}, + } + + for _, testCase := range testCases { + result := LogScale(testCase.input) + assert.Equal(t, testCase.expected, result, "LogScale(%d) failed", testCase.input) + } +} + +func TestHasPID(t *testing.T) { + pids := []lp2ppeer.ID{"peer1", "peer2", "peer3"} + + assert.True(t, HasPID(pids, lp2ppeer.ID("peer1"))) + assert.False(t, HasPID(pids, lp2ppeer.ID("peer4"))) +} + +func TestSubnetsToFilters(t *testing.T) { + sns := PrivateSubnets() + f := SubnetsToFilters(sns, multiaddr.ActionDeny) + + ma1, _ := multiaddr.NewMultiaddr("/ip4/0.0.0.0") + ma2, _ := multiaddr.NewMultiaddr("/ip4/127.0.0.1") + ma3, _ := multiaddr.NewMultiaddr("/ip4/8.8.8.8") + + assert.False(t, f.AddrBlocked(ma1)) + assert.True(t, f.AddrBlocked(ma2)) + assert.False(t, f.AddrBlocked(ma3)) +} + +func TestDetectPublicIPv4(t *testing.T) { + ip, ok := DetectPublicIPv4() + assert.True(t, ok) + assert.NotNil(t, ip) + + fmt.Println(ip) +} + +func TestDetectPublicIPv6(t *testing.T) { + ip, ok := DetectPublicIPv6() + if ok { + assert.NotNil(t, ip) + + fmt.Println(ip) + ma, _ := IPToMultiAddr(ip, 1234) + privateSubnets := PrivateSubnets() + privateFilters := SubnetsToFilters(privateSubnets, multiaddr.ActionDeny) + assert.False(t, privateFilters.AddrBlocked(ma)) + } +} diff --git a/tests/main_test.go b/tests/main_test.go index e9020d357..6dc59f32a 100644 --- a/tests/main_test.go +++ b/tests/main_test.go @@ -82,7 +82,7 @@ func TestMain(m *testing.M) { tConfigs[i].Sync.NodeNetwork = false tConfigs[i].Sync.Firewall.Enabled = false tConfigs[i].Network.EnableMdns = true - tConfigs[i].Network.PrivateNetwork = true + tConfigs[i].Network.ForcePrivateNetwork = true tConfigs[i].Network.Bootstrapper = true tConfigs[i].Network.NetworkKey = util.TempFilePath() tConfigs[i].Network.Listens = []string{"/ip4/127.0.0.1/tcp/0", "/ip4/127.0.0.1/udp/0/quic-v1"}