Network/firewall

[Ali-Meh]

Pactus Peer Firewall

---

What problem are you trying to solve?

• A node wants to listen to whitelisted peers Only or trying to blacklist some peers
• Config sub command to whitelist or blacklist peers and save them to a persistent store reusable for future detector algorithm

How do you propose to solve it?

• Add whitelist and blacklist sub-commands to Config command of CLI to add or remove peers.
• Don't connect to blacklisted peers and if already connected drop it via this ability
• Check to not connect to these peers or only connect to whitelist peers here.
• Implement Check on connectivity Check of bootstrap goroutine.

What other approaches did you consider?

• could just ignore the message published from these peers but it's resource intensive so i say just drop peer.

Proposed structs to add to network/firewall

// BootstrapConfig holds all configuration options related to bootstrap nodes
type BootstrapConfig struct {
	// Peers to connect to if we fall below the threshold.
	Addresses []string
	// MinPeerThreshold is the number of connections it attempts to maintain.
	MinThreshold int
	// MaxThreshold is the threshold of maximum number of connections.
	MaxThreshold int
	// Period is the interval at which it periodically checks to see
	// if the threshold is maintained.
	Period time.Duration
	// ConnectionTimeout is how long to wait before timing out a connection attempt.
	Timeout time.Duration
	//PeerFilters keeps track of whitelisted or blacklisted peers
	PeerFilters *PeerFilter
}

//PeerFilter has the list of peers to whitelist and a list to blacklist so never connect to blacklist and if set only whitelist
//flag is set then only allow whitelisted peers to connect
type PeerFilter struct {
	WhiteListedPeers []peer.AddrInfo
	BlackListedPeers []peer.AddrInfo
	OnlyWhiteList    bool
}

//PeerSelector is the func interface needs to be passed before starting to connect to the
//newly identified peers
type PeerSelector interface {
	//check to see if Peer is allowed to connect
	CanConnect(peer.ID) bool
	//Blacklist(true) adds /(false) will drop peer to/from Blacklisted peers list
	Blacklist(peer.ID, bool) error
	//Whitelist(true) adds /(false) will drop peer to/from whitelisted peers list
	Whitelist(peer.ID, bool) error
	//SetOnlyWhiteList will set PeerFilter.OnlyWhiteList
	SetOnlyWhiteList(bool) error
}

What could go wrong?

• May need to save IpAddress of the peer on blacklist subcommand for future use!
• Might be better to expose a channel to notifie PeerSelector of newly detected badPeer to blacklist but this way only needs to pass the network object to sync/firewall

---

@b00f @nagarajmanjunath

[Ali-Meh]

the initial test with this approach suggests gonna need better persistence method as toml config file might get so big

[State]
  MintbaseAddress = ""
  [State.Store]
    Path = "data"

[TxPool]
  WaitingTimeout = 2000000000
  MaxSize = 2000

[Consensus]
  TimeoutPrepare = 3000000000
  TimeoutPrecommit = 2000000000
  DeltaDuration = 1000000000

[Network]
  Name = "zarb"
  Address = "/ip4/0.0.0.0/tcp/0"
  NodeKeyFile = "node_key"
  EnableMDNS = true
  EnableKademlia = true
  [Network.Bootstrap]
    Addresses = []
    MinThreshold = 8
    MaxThreshold = 16
    Period = 60000000000
    Timeout = 20000000000
-----------------------------------------------------------------------------------------------
    [Network.Bootstrap.PeerFilters]
      OnlyWhiteList = true

      [[Network.Bootstrap.PeerFilters.WhiteListedPeers]]
        ID = "12D3KooWNYD4bB82YZRXv6oNyYPwc5ozabx2epv75ATV3D8VD3Mq"

        [[Network.Bootstrap.PeerFilters.WhiteListedPeers.Addrs]]
-----------------------------------------------------------------------------------------------
[Logger]
  Colorfull = true
  [Logger.Levels]
    _capnp = "error"
    _consensus = "info"
    _grpc = "error"
    _http = "error"
    _network = "error"
    _pool = "error"
    _state = "info"
    _sync = "warning"
    default = "info"

[Sync]
  Moniker = ""
  StartingTimeout = 5000000000
  HeartBeatTimeout = 5000000000
  SessionTimeout = 3000000000
  InitialBlockDownload = true
  BlockPerMessage = 10
  CacheSize = 100000

[Capnp]
  Enable = true
  Address = "[::]:37621"

[Http]
  Enable = true
  Address = "[::]:8081"

[GRPC]
  Enable = true
  Address = "[::]:9090"
  [GRPC.Gateway]
    Enable = true
    Address = "[::]:8080"

[b00f]

Thank @Ali-Meh for bringing this discussion up. I have some thought about it.

Trusted Peers

This is a good idea to have a list of trusted peers. When this list is empty, the node accepts all the messages from all the peers.
But if the list is not empty, the node only accept messages from the trusted peers. We can handle this behavior inside firewall package.

To black list or not

We can block or mute a peer by adding its peer ID into a black list. Note that because of the libp2p architecture, we don't have access to peers IP address.
However creating new peer id is cheap and a malicious client can easily generate fake ids.

We have two options:

• Don’t have any blacklist peers. I think Ethereum follows this approach.
• Having a database of blacklisted peers. Bitcoin following this approach by black listing IP addresses.

We can attach a database to the peer_set structure and keep the status of peers. This approach has a drawback. After a while the database will be filled with junk and stale peers info.

On the other hand, we can keep the list of connected peers in memory. We need to think about a garbage collector mechanism to remove old and stale peers from the map.

Node vs peer

At the first glance a node is same as peer in the p2p network. But they are slightly different terms. When we talk about the node, we emphasize the validator part of the client but peer mostly refers to the role of the client in the p2p network. This is why in peer structure we have public key and peer id.
The public key shows the public key of the validator and peer id refers to id of the peer. They are not the same.
Messages can be more secured by encrypting with node’s public key.