From 3b58f5a2c528fed1608308cb7ad78dea154cef80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Wed, 29 Apr 2015 18:04:08 +0300 Subject: [PATCH 1/6] cmd/geth, cmd/mist, cmd/utils, eth, p2p: support trusted peers --- cmd/geth/admin.go | 6 ++-- cmd/geth/main.go | 3 +- cmd/mist/main.go | 2 +- cmd/mist/ui_lib.go | 4 +-- cmd/utils/flags.go | 10 ++++-- eth/backend.go | 56 ++++++++++++++++++++++++++--- p2p/server.go | 90 +++++++++++++++++++++++++++++++++++++++------- p2p/server_test.go | 2 +- 8 files changed, 146 insertions(+), 27 deletions(-) diff --git a/cmd/geth/admin.go b/cmd/geth/admin.go index 31f8d44004..a07e694dee 100644 --- a/cmd/geth/admin.go +++ b/cmd/geth/admin.go @@ -25,7 +25,7 @@ func (js *jsre) adminBindings() { js.re.Set("admin", struct{}{}) t, _ := js.re.Get("admin") admin := t.Object() - admin.Set("suggestPeer", js.suggestPeer) + admin.Set("trustPeer", js.trustPeer) admin.Set("startRPC", js.startRPC) admin.Set("stopRPC", js.stopRPC) admin.Set("nodeInfo", js.nodeInfo) @@ -243,13 +243,13 @@ func (js *jsre) stopRPC(call otto.FunctionCall) otto.Value { return otto.FalseValue() } -func (js *jsre) suggestPeer(call otto.FunctionCall) otto.Value { +func (js *jsre) trustPeer(call otto.FunctionCall) otto.Value { nodeURL, err := call.Argument(0).ToString() if err != nil { fmt.Println(err) return otto.FalseValue() } - err = js.ethereum.SuggestPeer(nodeURL) + err = js.ethereum.TrustPeer(nodeURL) if err != nil { fmt.Println(err) return otto.FalseValue() diff --git a/cmd/geth/main.go b/cmd/geth/main.go index 365390a07c..9538abe0cb 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -232,7 +232,8 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso utils.IdentityFlag, utils.UnlockedAccountFlag, utils.PasswordFileFlag, - utils.BootnodesFlag, + utils.BootNodesFlag, + utils.TrustedNodesFlag, utils.DataDirFlag, utils.BlockchainVersionFlag, utils.JSpathFlag, diff --git a/cmd/mist/main.go b/cmd/mist/main.go index 1030d6ada1..18fb919b45 100644 --- a/cmd/mist/main.go +++ b/cmd/mist/main.go @@ -69,7 +69,7 @@ func init() { assetPathFlag, rpcCorsFlag, - utils.BootnodesFlag, + utils.BootNodesFlag, utils.DataDirFlag, utils.ListenPortFlag, utils.LogFileFlag, diff --git a/cmd/mist/ui_lib.go b/cmd/mist/ui_lib.go index 34ce56e77b..e1a3aa2543 100644 --- a/cmd/mist/ui_lib.go +++ b/cmd/mist/ui_lib.go @@ -104,8 +104,8 @@ func (ui *UiLib) Connect(button qml.Object) { } func (ui *UiLib) ConnectToPeer(nodeURL string) { - if err := ui.eth.SuggestPeer(nodeURL); err != nil { - guilogger.Infoln("SuggestPeer error: " + err.Error()) + if err := ui.eth.TrustPeer(nodeURL); err != nil { + guilogger.Infoln("TrustPeer error: " + err.Error()) } } diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index c013510d82..f52bfc21f0 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -202,11 +202,16 @@ var ( Usage: "Network listening port", Value: 30303, } - BootnodesFlag = cli.StringFlag{ + BootNodesFlag = cli.StringFlag{ Name: "bootnodes", Usage: "Space-separated enode URLs for p2p discovery bootstrap", Value: "", } + TrustedNodesFlag = cli.StringFlag{ + Name: "trustednodes", + Usage: "List of trusted nodes (either an enode list or path to a json file of enodes)", + Value: "", + } NodeKeyFileFlag = cli.StringFlag{ Name: "nodekey", Usage: "P2P node key file", @@ -292,7 +297,8 @@ func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config { NodeKey: GetNodeKey(ctx), Shh: ctx.GlobalBool(WhisperEnabledFlag.Name), Dial: true, - BootNodes: ctx.GlobalString(BootnodesFlag.Name), + BootNodes: ctx.GlobalString(BootNodesFlag.Name), + TrustedNodes: ctx.GlobalString(TrustedNodesFlag.Name), } } diff --git a/eth/backend.go b/eth/backend.go index c5fa328b05..f8d57c9855 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -2,7 +2,10 @@ package eth import ( "crypto/ecdsa" + "encoding/json" "fmt" + "io/ioutil" + "os" "path" "strings" "time" @@ -56,10 +59,13 @@ type Config struct { MaxPeers int Port string - // This should be a space-separated list of - // discovery node URLs. + // Space-separated list of discovery node URLs BootNodes string + // Either a space-separated list of discovery node URLs, or a path to a json + // file containing such a list. + TrustedNodes string + // This key is used to identify the node on the network. // If nil, an ephemeral key is used. NodeKey *ecdsa.PrivateKey @@ -96,6 +102,46 @@ func (cfg *Config) parseBootNodes() []*discover.Node { return ns } +// parseTrustedNodes parses a list of discovery node URLs either given literally, +// or loaded from a .json file. +func (cfg *Config) parseTrustedNodes() []*discover.Node { + // Short circuit if no trusted nodes were given + if cfg.TrustedNodes == "" { + return nil + } + // Try to interpret the trusted node config as a .json file + if _, err := os.Stat(cfg.TrustedNodes); err == nil { + // Load the file from disk + blob, err := ioutil.ReadFile(cfg.TrustedNodes) + if err != nil { + glog.V(logger.Error).Infof("Failed to access trusted nodes: %v", err) + return nil + } + // Interpret the json contents + list := []string{} + if err := json.Unmarshal(blob, &list); err != nil { + glog.V(logger.Error).Infof("Failed to load trusted nodes: %v", err) + return nil + } + // Swap out the configuration for the actual nodes + cfg.TrustedNodes = strings.Join(list, " ") + } + // Interpret the list as a discovery node array + var nodes []*discover.Node + for _, url := range strings.Split(cfg.TrustedNodes, " ") { + if url == "" { + continue + } + node, err := discover.ParseNode(url) + if err != nil { + glog.V(logger.Error).Infof("Trusted node URL %s: %v\n", url, err) + continue + } + nodes = append(nodes, node) + } + return nodes +} + func (cfg *Config) nodeKey() (*ecdsa.PrivateKey, error) { // use explicit key from command line args if set if cfg.NodeKey != nil { @@ -247,6 +293,7 @@ func New(config *Config) (*Ethereum, error) { NAT: config.NAT, NoDial: !config.Dial, BootstrapNodes: config.parseBootNodes(), + TrustedNodes: config.parseTrustedNodes(), NodeDatabase: nodeDb, } if len(config.Port) > 0 { @@ -442,12 +489,13 @@ func (s *Ethereum) StartForTest() { s.txPool.Start() } -func (self *Ethereum) SuggestPeer(nodeURL string) error { +// TrustPeer injects a new node into the list of privileged nodes. +func (self *Ethereum) TrustPeer(nodeURL string) error { n, err := discover.ParseNode(nodeURL) if err != nil { return fmt.Errorf("invalid node URL: %v", err) } - self.net.SuggestPeer(n) + self.net.TrustPeer(n) return nil } diff --git a/p2p/server.go b/p2p/server.go index 5c5883ae8d..794c361256 100644 --- a/p2p/server.go +++ b/p2p/server.go @@ -18,8 +18,9 @@ import ( ) const ( - defaultDialTimeout = 10 * time.Second - refreshPeersInterval = 30 * time.Second + defaultDialTimeout = 10 * time.Second + refreshPeersInterval = 30 * time.Second + trustedPeerCheckInterval = 15 * time.Second // This is the maximum number of inbound connection // that are allowed to linger between 'accepted' and @@ -59,6 +60,10 @@ type Server struct { // with the rest of the network. BootstrapNodes []*discover.Node + // Trusted nodes are used as privileged connections which are always accepted + // and also always maintained. + TrustedNodes []*discover.Node + // NodeDatabase is the path to the database containing the previously seen // live nodes in the network. NodeDatabase string @@ -99,13 +104,15 @@ type Server struct { running bool peers map[discover.NodeID]*Peer + trusts map[discover.NodeID]*discover.Node // Map of currently trusted remote nodes + trustDial chan *discover.Node // Dial request channel reserved for the trusted nodes + ntab *discover.Table listener net.Listener - quit chan struct{} - loopWG sync.WaitGroup // {dial,listen,nat}Loop - peerWG sync.WaitGroup // active peer goroutines - peerConnect chan *discover.Node + quit chan struct{} + loopWG sync.WaitGroup // {dial,listen,nat}Loop + peerWG sync.WaitGroup // active peer goroutines } type setupFunc func(net.Conn, *ecdsa.PrivateKey, *protoHandshake, *discover.Node, bool) (*conn, error) @@ -131,10 +138,9 @@ func (srv *Server) PeerCount() int { return n } -// SuggestPeer creates a connection to the given Node if it -// is not already connected. -func (srv *Server) SuggestPeer(n *discover.Node) { - srv.peerConnect <- n +// TrustPeer inserts a node into the list of privileged nodes. +func (srv *Server) TrustPeer(node *discover.Node) { + srv.trustDial <- node } // Broadcast sends an RLP-encoded message to all connected peers. @@ -195,7 +201,14 @@ func (srv *Server) Start() (err error) { } srv.quit = make(chan struct{}) srv.peers = make(map[discover.NodeID]*Peer) - srv.peerConnect = make(chan *discover.Node) + + // Create the current trust map, and the associated dialing channel + srv.trusts = make(map[discover.NodeID]*discover.Node) + for _, node := range srv.TrustedNodes { + srv.trusts[node.ID] = node + } + srv.trustDial = make(chan *discover.Node) + if srv.setupFunc == nil { srv.setupFunc = setupConn } @@ -229,6 +242,8 @@ func (srv *Server) Start() (err error) { if srv.NoDial && srv.ListenAddr == "" { glog.V(logger.Warn).Infoln("I will be kind-of useless, neither dialing nor listening.") } + // maintain the trusted peers + go srv.trustLoop() srv.running = true return nil @@ -323,6 +338,45 @@ func (srv *Server) listenLoop() { } } +// trustLoop is responsible for periodically checking that trusted connections +// are actually live, and requests dialing if not. +func (srv *Server) trustLoop() { + // Create a ticker for verifying trusted connections + tick := time.Tick(trustedPeerCheckInterval) + + for { + select { + case <-srv.quit: + // Termination requested, simple return + return + + case <-tick: + // Collect all the non-connected trusted nodes + needed := []*discover.Node{} + srv.lock.RLock() + for id, node := range srv.trusts { + if _, ok := srv.peers[id]; !ok { + needed = append(needed, node) + } + } + srv.lock.RUnlock() + + // Try to dial each of them (don't hang if server terminates) + for _, node := range needed { + glog.V(logger.Error).Infof("Dialing trusted peer %v", node) + select { + case srv.trustDial <- node: + // Ok, dialing + + case <-srv.quit: + // Terminating, return + return + } + } + } + } +} + func (srv *Server) dialLoop() { var ( dialed = make(chan *discover.Node) @@ -373,7 +427,7 @@ func (srv *Server) dialLoop() { // below MaxPeers. refresh.Reset(refreshPeersInterval) } - case dest := <-srv.peerConnect: + case dest := <-srv.trustDial: dial(dest) case dests := <-findresults: for _, dest := range dests { @@ -472,16 +526,26 @@ func (srv *Server) addPeer(id discover.NodeID, p *Peer) (bool, DiscReason) { return true, 0 } +// checkPeer verifies whether a peer looks promising and should be allowed/kept +// in the pool, or if it's of no use. func (srv *Server) checkPeer(id discover.NodeID) (bool, DiscReason) { + // First up, figure out if the peer is trusted + _, trusted := srv.trusts[id] + + // Make sure the peer passes all required checks switch { case !srv.running: return false, DiscQuitting - case len(srv.peers) >= srv.MaxPeers: + + case !trusted && len(srv.peers) >= srv.MaxPeers: return false, DiscTooManyPeers + case srv.peers[id] != nil: return false, DiscAlreadyConnected + case id == srv.ntab.Self().ID: return false, DiscSelf + default: return true, 0 } diff --git a/p2p/server_test.go b/p2p/server_test.go index 53cc3c2582..e99d37ed05 100644 --- a/p2p/server_test.go +++ b/p2p/server_test.go @@ -102,7 +102,7 @@ func TestServerDial(t *testing.T) { // tell the server to connect tcpAddr := listener.Addr().(*net.TCPAddr) - srv.SuggestPeer(&discover.Node{IP: tcpAddr.IP, TCPPort: tcpAddr.Port}) + srv.trustDial <-&discover.Node{IP: tcpAddr.IP, TCPPort: tcpAddr.Port} select { case conn := <-accepted: From 5dde733d0c1d620a29197b58b312eaf5ace7ef3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Wed, 29 Apr 2015 18:42:43 +0300 Subject: [PATCH 2/6] p2p: add a dialer cooldown to prevent reattempting failures --- p2p/peer_error.go | 2 ++ p2p/server.go | 26 +++++++++++++++++++++++--- 2 files changed, 25 insertions(+), 3 deletions(-) diff --git a/p2p/peer_error.go b/p2p/peer_error.go index a912f60644..d9c09a9c6c 100644 --- a/p2p/peer_error.go +++ b/p2p/peer_error.go @@ -73,6 +73,7 @@ const ( DiscSelf DiscReadTimeout DiscSubprotocolError + DiscFailureCooldown ) var discReasonToString = [...]string{ @@ -89,6 +90,7 @@ var discReasonToString = [...]string{ DiscSelf: "Connected to self", DiscReadTimeout: "Read timeout", DiscSubprotocolError: "Subprotocol error", + DiscFailureCooldown: "Failure cooldown", } func (d DiscReason) String() string { diff --git a/p2p/server.go b/p2p/server.go index 794c361256..1f15ca2011 100644 --- a/p2p/server.go +++ b/p2p/server.go @@ -21,6 +21,7 @@ const ( defaultDialTimeout = 10 * time.Second refreshPeersInterval = 30 * time.Second trustedPeerCheckInterval = 15 * time.Second + dialFailureCooldown = 30 * time.Second // This is the maximum number of inbound connection // that are allowed to linger between 'accepted' and @@ -100,9 +101,11 @@ type Server struct { ourHandshake *protoHandshake - lock sync.RWMutex // protects running and peers + lock sync.RWMutex // protects running and peers + running bool - peers map[discover.NodeID]*Peer + peers map[discover.NodeID]*Peer // Currently active peer pool + fails map[discover.NodeID]bool // List of recently failed connections trusts map[discover.NodeID]*discover.Node // Map of currently trusted remote nodes trustDial chan *discover.Node // Dial request channel reserved for the trusted nodes @@ -201,6 +204,7 @@ func (srv *Server) Start() (err error) { } srv.quit = make(chan struct{}) srv.peers = make(map[discover.NodeID]*Peer) + srv.fails = make(map[discover.NodeID]bool) // Create the current trust map, and the associated dialing channel srv.trusts = make(map[discover.NodeID]*discover.Node) @@ -456,7 +460,20 @@ func (srv *Server) dialNode(dest *discover.Node) { // dialNode, so we need to count it down again. startPeer also // does that when an error occurs. srv.peerWG.Done() - glog.V(logger.Detail).Infof("dial error: %v", err) + + // Mark the dialing as failed so prevent too fast redials, and set a + // timer for re-allowing dialing + srv.lock.Lock() + srv.fails[dest.ID] = true + srv.lock.Unlock() + go func() { + glog.V(logger.Detail).Infof("Dialing %v failed: %v. Locked until %v\n", dest, err, time.Now().Add(dialFailureCooldown)) + <-time.After(dialFailureCooldown) + + srv.lock.Lock() + delete(srv.fails, dest.ID) + srv.lock.Unlock() + }() return } srv.startPeer(conn, dest) @@ -546,6 +563,9 @@ func (srv *Server) checkPeer(id discover.NodeID) (bool, DiscReason) { case id == srv.ntab.Self().ID: return false, DiscSelf + case srv.fails[id]: + return false, DiscFailureCooldown + default: return true, 0 } From e6efa4e2d7f77b9804589a64b7122bc12ce60764 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Wed, 29 Apr 2015 18:50:52 +0300 Subject: [PATCH 3/6] cmd/geth, cmd/utils, eth: internalize trusted node config file --- cmd/geth/main.go | 1 - cmd/utils/flags.go | 6 ------ eth/backend.go | 43 ++++++++++++++++++++----------------------- 3 files changed, 20 insertions(+), 30 deletions(-) diff --git a/cmd/geth/main.go b/cmd/geth/main.go index 9538abe0cb..854ad47a9e 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -233,7 +233,6 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso utils.UnlockedAccountFlag, utils.PasswordFileFlag, utils.BootNodesFlag, - utils.TrustedNodesFlag, utils.DataDirFlag, utils.BlockchainVersionFlag, utils.JSpathFlag, diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index f52bfc21f0..62b49cddcc 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -207,11 +207,6 @@ var ( Usage: "Space-separated enode URLs for p2p discovery bootstrap", Value: "", } - TrustedNodesFlag = cli.StringFlag{ - Name: "trustednodes", - Usage: "List of trusted nodes (either an enode list or path to a json file of enodes)", - Value: "", - } NodeKeyFileFlag = cli.StringFlag{ Name: "nodekey", Usage: "P2P node key file", @@ -298,7 +293,6 @@ func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config { Shh: ctx.GlobalBool(WhisperEnabledFlag.Name), Dial: true, BootNodes: ctx.GlobalString(BootNodesFlag.Name), - TrustedNodes: ctx.GlobalString(TrustedNodesFlag.Name), } } diff --git a/eth/backend.go b/eth/backend.go index f8d57c9855..c69e4a27a8 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -7,6 +7,7 @@ import ( "io/ioutil" "os" "path" + "path/filepath" "strings" "time" @@ -39,6 +40,9 @@ var ( // ETH/DEV cpp-ethereum (poc-9.ethdev.com) discover.MustParseNode("enode://487611428e6c99a11a9795a6abe7b529e81315ca6aad66e2a2fc76e3adf263faba0d35466c2f8f68d561dbefa8878d4df5f1f2ddb1fbeab7f42ffb8cd328bd4a@5.1.83.226:30303"), } + + // Path within to search for the trusted node list + trustedNodes = "trusted-nodes.json" ) type Config struct { @@ -62,10 +66,6 @@ type Config struct { // Space-separated list of discovery node URLs BootNodes string - // Either a space-separated list of discovery node URLs, or a path to a json - // file containing such a list. - TrustedNodes string - // This key is used to identify the node on the network. // If nil, an ephemeral key is used. NodeKey *ecdsa.PrivateKey @@ -105,30 +105,27 @@ func (cfg *Config) parseBootNodes() []*discover.Node { // parseTrustedNodes parses a list of discovery node URLs either given literally, // or loaded from a .json file. func (cfg *Config) parseTrustedNodes() []*discover.Node { - // Short circuit if no trusted nodes were given - if cfg.TrustedNodes == "" { + // Short circuit if no trusted node config is present + path := filepath.Join(cfg.DataDir, trustedNodes) + if _, err := os.Stat(path); err != nil { + fmt.Println("nodes", nil) return nil } - // Try to interpret the trusted node config as a .json file - if _, err := os.Stat(cfg.TrustedNodes); err == nil { - // Load the file from disk - blob, err := ioutil.ReadFile(cfg.TrustedNodes) - if err != nil { - glog.V(logger.Error).Infof("Failed to access trusted nodes: %v", err) - return nil - } - // Interpret the json contents - list := []string{} - if err := json.Unmarshal(blob, &list); err != nil { - glog.V(logger.Error).Infof("Failed to load trusted nodes: %v", err) - return nil - } - // Swap out the configuration for the actual nodes - cfg.TrustedNodes = strings.Join(list, " ") + // Load the trusted nodes from the config file + blob, err := ioutil.ReadFile(path) + if err != nil { + glog.V(logger.Error).Infof("Failed to access trusted nodes: %v", err) + return nil } + nodelist := []string{} + if err := json.Unmarshal(blob, &nodelist); err != nil { + glog.V(logger.Error).Infof("Failed to load trusted nodes: %v", err) + return nil + } + fmt.Println("nodes", nodelist) // Interpret the list as a discovery node array var nodes []*discover.Node - for _, url := range strings.Split(cfg.TrustedNodes, " ") { + for _, url := range nodelist { if url == "" { continue } From 1b9564ddba7b3d89ddc2872a377d0eafef5e11ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Wed, 29 Apr 2015 18:59:08 +0300 Subject: [PATCH 4/6] p2p: reduce the severity of a debug log --- p2p/server.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/p2p/server.go b/p2p/server.go index 1f15ca2011..c08992d2c2 100644 --- a/p2p/server.go +++ b/p2p/server.go @@ -367,7 +367,7 @@ func (srv *Server) trustLoop() { // Try to dial each of them (don't hang if server terminates) for _, node := range needed { - glog.V(logger.Error).Infof("Dialing trusted peer %v", node) + glog.V(logger.Debug).Infof("Dialing trusted peer %v", node) select { case srv.trustDial <- node: // Ok, dialing From 805f0eef2cce16600f11915a8d7c92c3019aedad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Thu, 30 Apr 2015 11:45:59 +0300 Subject: [PATCH 5/6] p2p: throttle peers on remote close too, add throttling tests --- p2p/peer_error.go | 4 +- p2p/server.go | 49 ++++++++++++------- p2p/server_test.go | 114 ++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 145 insertions(+), 22 deletions(-) diff --git a/p2p/peer_error.go b/p2p/peer_error.go index d9c09a9c6c..bab1696d59 100644 --- a/p2p/peer_error.go +++ b/p2p/peer_error.go @@ -73,7 +73,7 @@ const ( DiscSelf DiscReadTimeout DiscSubprotocolError - DiscFailureCooldown + DiscThrottled ) var discReasonToString = [...]string{ @@ -90,7 +90,7 @@ var discReasonToString = [...]string{ DiscSelf: "Connected to self", DiscReadTimeout: "Read timeout", DiscSubprotocolError: "Subprotocol error", - DiscFailureCooldown: "Failure cooldown", + DiscThrottled: "Node throttled", } func (d DiscReason) String() string { diff --git a/p2p/server.go b/p2p/server.go index c08992d2c2..bc41e48c37 100644 --- a/p2p/server.go +++ b/p2p/server.go @@ -103,9 +103,9 @@ type Server struct { lock sync.RWMutex // protects running and peers - running bool - peers map[discover.NodeID]*Peer // Currently active peer pool - fails map[discover.NodeID]bool // List of recently failed connections + running bool + peers map[discover.NodeID]*Peer // Currently active peer pool + throttle map[discover.NodeID]bool // List of recently failed connections trusts map[discover.NodeID]*discover.Node // Map of currently trusted remote nodes trustDial chan *discover.Node // Dial request channel reserved for the trusted nodes @@ -204,7 +204,7 @@ func (srv *Server) Start() (err error) { } srv.quit = make(chan struct{}) srv.peers = make(map[discover.NodeID]*Peer) - srv.fails = make(map[discover.NodeID]bool) + srv.throttle = make(map[discover.NodeID]bool) // Create the current trust map, and the associated dialing channel srv.trusts = make(map[discover.NodeID]*discover.Node) @@ -461,24 +461,33 @@ func (srv *Server) dialNode(dest *discover.Node) { // does that when an error occurs. srv.peerWG.Done() - // Mark the dialing as failed so prevent too fast redials, and set a - // timer for re-allowing dialing - srv.lock.Lock() - srv.fails[dest.ID] = true - srv.lock.Unlock() - go func() { - glog.V(logger.Detail).Infof("Dialing %v failed: %v. Locked until %v\n", dest, err, time.Now().Add(dialFailureCooldown)) - <-time.After(dialFailureCooldown) + // Throttle the node to prevent hammering it with connections + glog.V(logger.Detail).Infof("Dialing %v failed: %v, throttling", dest, err) + srv.throttleNode(dest.ID) - srv.lock.Lock() - delete(srv.fails, dest.ID) - srv.lock.Unlock() - }() return } srv.startPeer(conn, dest) } +// throttleNode temporarily throttles a node, disabling both egress as well as +// ingress connections to/from that particular node. +func (srv *Server) throttleNode(id discover.NodeID) { + // Mark the node as throttled + srv.lock.Lock() + srv.throttle[id] = true + srv.lock.Unlock() + + // Wait a while, after which discard the throttling + go func() { + <-time.After(dialFailureCooldown) + + srv.lock.Lock() + delete(srv.throttle, id) + srv.lock.Unlock() + }() +} + func (srv *Server) startPeer(fd net.Conn, dest *discover.Node) { // TODO: handle/store session token @@ -525,7 +534,11 @@ func (srv *Server) runPeer(p *Peer) { srv.newPeerHook(p) } discreason := p.run() + + // Drop the node, and throttle it to prevent hammering srv.removePeer(p) + srv.throttleNode(p.ID()) + glog.V(logger.Debug).Infof("Removed %v (%v)\n", p, discreason) srvjslog.LogJson(&logger.P2PDisconnected{ RemoteId: p.ID().String(), @@ -563,8 +576,8 @@ func (srv *Server) checkPeer(id discover.NodeID) (bool, DiscReason) { case id == srv.ntab.Self().ID: return false, DiscSelf - case srv.fails[id]: - return false, DiscFailureCooldown + case srv.throttle[id]: + return false, DiscThrottled default: return true, 0 diff --git a/p2p/server_test.go b/p2p/server_test.go index e99d37ed05..3bc928fcae 100644 --- a/p2p/server_test.go +++ b/p2p/server_test.go @@ -80,7 +80,7 @@ func TestServerDial(t *testing.T) { // run a one-shot TCP server to handle the connection. listener, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { - t.Fatalf("could not setup listener: %v") + t.Fatalf("could not setup listener: %v", err) } defer listener.Close() accepted := make(chan net.Conn) @@ -102,7 +102,7 @@ func TestServerDial(t *testing.T) { // tell the server to connect tcpAddr := listener.Addr().(*net.TCPAddr) - srv.trustDial <-&discover.Node{IP: tcpAddr.IP, TCPPort: tcpAddr.Port} + srv.trustDial <- &discover.Node{IP: tcpAddr.IP, TCPPort: tcpAddr.Port} select { case conn := <-accepted: @@ -219,6 +219,116 @@ func TestServerDisconnectAtCap(t *testing.T) { } } +// Tests that a failed dial will temporarily throttle a peer. +func TestServerOutboundThrottling(t *testing.T) { + defer testlog(t).detach() + + // Start a simple test server + server := startTestServer(t, nil) + defer server.Stop() + + // Request a failing dial from the server and check throttling + node := &discover.Node{ + ID: discover.PubkeyID(&newkey().PublicKey), + IP: []byte{127, 0, 0, 1}, + TCPPort: 65535, + } + server.trustDial <- node + + time.Sleep(100 * time.Millisecond) + if throttle := server.throttle[node.ID]; !throttle { + t.Fatalf("throttling mismatch: have %v, want %v", throttle, true) + } + // Open a one shot TCP server to listen for valid dialing + listener, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("failed to setup listener: %v", err) + } + defer listener.Close() + + connected := make(chan net.Conn) + go func() { + conn, err := listener.Accept() + if err == nil { + conn.Close() + connected <- conn + } + }() + time.Sleep(100 * time.Millisecond) + + // Request a re-dial from the server, make sure this also fails + addr := listener.Addr().(*net.TCPAddr) + node.IP, node.TCPPort = addr.IP, addr.Port + server.trustDial <- node + + select { + case peer := <-connected: + t.Fatalf("throttled peer connected: %v", peer) + + case <-time.After(100 * time.Millisecond): + // Ok, peer not accepted + } +} + +// Tests that a failed peer will get temporarily throttled. +func TestServerInboundThrottling(t *testing.T) { + defer testlog(t).detach() + + // Start a test server and a peer sink for synchronization + started := make(chan *Peer) + server := &Server{ + ListenAddr: "127.0.0.1:0", + PrivateKey: newkey(), + MaxPeers: 10, + NoDial: true, + newPeerHook: func(p *Peer) { started <- p }, + } + if err := server.Start(); err != nil { + t.Fatal("failed to start test server: %v", err) + } + defer server.Stop() + + // Create a new peer identity to check throttling with + dialer := &net.Dialer{Deadline: time.Now().Add(3 * time.Second)} + key := newkey() + + // Connect with a new peer, run the handshake and disconnect + connection, err := dialer.Dial("tcp", server.ListenAddr) + if err != nil { + t.Fatalf("failed to dial server: %v", err) + } + shake := &protoHandshake{Version: baseProtocolVersion, ID: discover.PubkeyID(&key.PublicKey)} + if _, err = setupConn(connection, key, shake, server.Self(), false); err != nil { + t.Fatalf("failed to run handshake: %v", err) + } + <-started + connection.Close() + server.peerWG.Wait() + + // Check that throttling has been enabled + if throttle := server.throttle[shake.ID]; !throttle { + t.Fatalf("throttling mismatch: have %v, want %v", throttle, true) + } + // Try to reconnect with the same peer, run the handshake and verify throttling + connection, err = dialer.Dial("tcp", server.ListenAddr) + if err != nil { + t.Fatalf("failed to re-dial server: %v", err) + } + defer connection.Close() + + shake = &protoHandshake{Version: baseProtocolVersion, ID: discover.PubkeyID(&key.PublicKey)} + if _, err = setupConn(connection, key, shake, server.Self(), false); err != nil { + t.Fatalf("failed to re-run handshake: %v", err) + } + select { + case peer := <-started: + t.Fatalf("throttled peer accepted: %v", peer) + + case <-time.After(100 * time.Millisecond): + // Ok, peer not accepted + } +} + func newkey() *ecdsa.PrivateKey { key, err := crypto.GenerateKey() if err != nil { From 19f23474729f5f839598bc93baae87334ee6046e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Thu, 30 Apr 2015 12:41:27 +0300 Subject: [PATCH 6/6] p2p: add trust check to handshake, test privileged connectivity --- p2p/handshake.go | 14 ++++----- p2p/handshake_test.go | 4 +-- p2p/server.go | 17 +++++++++-- p2p/server_test.go | 70 ++++++++++++++++++++++++++++++++++++++++--- 4 files changed, 89 insertions(+), 16 deletions(-) diff --git a/p2p/handshake.go b/p2p/handshake.go index 79395f23ff..280b5068e7 100644 --- a/p2p/handshake.go +++ b/p2p/handshake.go @@ -70,21 +70,21 @@ type protoHandshake struct { // If dial is non-nil, the connection the local node is the initiator. // If atcap is true, the connection will be disconnected with DiscTooManyPeers // after the key exchange. -func setupConn(fd net.Conn, prv *ecdsa.PrivateKey, our *protoHandshake, dial *discover.Node, atcap bool) (*conn, error) { +func setupConn(fd net.Conn, prv *ecdsa.PrivateKey, our *protoHandshake, dial *discover.Node, atcap bool, trust map[discover.NodeID]bool) (*conn, error) { if dial == nil { - return setupInboundConn(fd, prv, our, atcap) + return setupInboundConn(fd, prv, our, atcap, trust) } else { - return setupOutboundConn(fd, prv, our, dial, atcap) + return setupOutboundConn(fd, prv, our, dial, atcap, trust) } } -func setupInboundConn(fd net.Conn, prv *ecdsa.PrivateKey, our *protoHandshake, atcap bool) (*conn, error) { +func setupInboundConn(fd net.Conn, prv *ecdsa.PrivateKey, our *protoHandshake, atcap bool, trust map[discover.NodeID]bool) (*conn, error) { secrets, err := receiverEncHandshake(fd, prv, nil) if err != nil { return nil, fmt.Errorf("encryption handshake failed: %v", err) } rw := newRlpxFrameRW(fd, secrets) - if atcap { + if atcap && !trust[secrets.RemoteID] { SendItems(rw, discMsg, DiscTooManyPeers) return nil, errors.New("we have too many peers") } @@ -99,13 +99,13 @@ func setupInboundConn(fd net.Conn, prv *ecdsa.PrivateKey, our *protoHandshake, a return &conn{rw, rhs}, nil } -func setupOutboundConn(fd net.Conn, prv *ecdsa.PrivateKey, our *protoHandshake, dial *discover.Node, atcap bool) (*conn, error) { +func setupOutboundConn(fd net.Conn, prv *ecdsa.PrivateKey, our *protoHandshake, dial *discover.Node, atcap bool, trust map[discover.NodeID]bool) (*conn, error) { secrets, err := initiatorEncHandshake(fd, prv, dial.ID, nil) if err != nil { return nil, fmt.Errorf("encryption handshake failed: %v", err) } rw := newRlpxFrameRW(fd, secrets) - if atcap { + if atcap && !trust[secrets.RemoteID] { SendItems(rw, discMsg, DiscTooManyPeers) return nil, errors.New("we have too many peers") } diff --git a/p2p/handshake_test.go b/p2p/handshake_test.go index c22af7a9c7..5e63e5c390 100644 --- a/p2p/handshake_test.go +++ b/p2p/handshake_test.go @@ -143,7 +143,7 @@ func TestSetupConn(t *testing.T) { done := make(chan struct{}) go func() { defer close(done) - conn0, err := setupConn(fd0, prv0, hs0, node1, false) + conn0, err := setupConn(fd0, prv0, hs0, node1, false, nil) if err != nil { t.Errorf("outbound side error: %v", err) return @@ -156,7 +156,7 @@ func TestSetupConn(t *testing.T) { } }() - conn1, err := setupConn(fd1, prv1, hs1, nil, false) + conn1, err := setupConn(fd1, prv1, hs1, nil, false, nil) if err != nil { t.Fatalf("inbound side error: %v", err) } diff --git a/p2p/server.go b/p2p/server.go index bc41e48c37..8359c9e71f 100644 --- a/p2p/server.go +++ b/p2p/server.go @@ -118,7 +118,7 @@ type Server struct { peerWG sync.WaitGroup // active peer goroutines } -type setupFunc func(net.Conn, *ecdsa.PrivateKey, *protoHandshake, *discover.Node, bool) (*conn, error) +type setupFunc func(net.Conn, *ecdsa.PrivateKey, *protoHandshake, *discover.Node, bool, map[discover.NodeID]bool) (*conn, error) type newPeerHook func(*Peer) // Peers returns all connected peers. @@ -143,7 +143,10 @@ func (srv *Server) PeerCount() int { // TrustPeer inserts a node into the list of privileged nodes. func (srv *Server) TrustPeer(node *discover.Node) { - srv.trustDial <- node + srv.lock.Lock() + defer srv.lock.Unlock() + + srv.trusts[node.ID] = node } // Broadcast sends an RLP-encoded message to all connected peers. @@ -496,10 +499,18 @@ func (srv *Server) startPeer(fd net.Conn, dest *discover.Node) { // returns during that exchange need to call peerWG.Done because // the callers of startPeer added the peer to the wait group already. fd.SetDeadline(time.Now().Add(handshakeTimeout)) + + // Check capacity and trust list srv.lock.RLock() atcap := len(srv.peers) == srv.MaxPeers + + trust := make(map[discover.NodeID]bool) + for id, _ := range srv.trusts { + trust[id] = true + } srv.lock.RUnlock() - conn, err := srv.setupFunc(fd, srv.PrivateKey, srv.ourHandshake, dest, atcap) + + conn, err := srv.setupFunc(fd, srv.PrivateKey, srv.ourHandshake, dest, atcap, trust) if err != nil { fd.Close() glog.V(logger.Debug).Infof("Handshake with %v failed: %v", fd.RemoteAddr(), err) diff --git a/p2p/server_test.go b/p2p/server_test.go index 3bc928fcae..679ed79733 100644 --- a/p2p/server_test.go +++ b/p2p/server_test.go @@ -22,7 +22,7 @@ func startTestServer(t *testing.T, pf newPeerHook) *Server { ListenAddr: "127.0.0.1:0", PrivateKey: newkey(), newPeerHook: pf, - setupFunc: func(fd net.Conn, prv *ecdsa.PrivateKey, our *protoHandshake, dial *discover.Node, atcap bool) (*conn, error) { + setupFunc: func(fd net.Conn, prv *ecdsa.PrivateKey, our *protoHandshake, dial *discover.Node, atcap bool, trust map[discover.NodeID]bool) (*conn, error) { id := randomID() rw := newRlpxFrameRW(fd, secrets{ MAC: zero16, @@ -200,7 +200,7 @@ func TestServerDisconnectAtCap(t *testing.T) { // Run the handshakes just like a real peer would. key := newkey() hs := &protoHandshake{Version: baseProtocolVersion, ID: discover.PubkeyID(&key.PublicKey)} - _, err = setupConn(conn, key, hs, srv.Self(), false) + _, err = setupConn(conn, key, hs, srv.Self(), false, nil) if i == nconns-1 { // When handling the last connection, the server should // disconnect immediately instead of running the protocol @@ -219,6 +219,68 @@ func TestServerDisconnectAtCap(t *testing.T) { } } +// Tests that trusted peers and can connect above max peer caps. +func TestServerTrustedPeers(t *testing.T) { + defer testlog(t).detach() + + // Create a test server with limited connection slots + started := make(chan *Peer) + server := &Server{ + ListenAddr: "127.0.0.1:0", + PrivateKey: newkey(), + MaxPeers: 3, + NoDial: true, + newPeerHook: func(p *Peer) { started <- p }, + } + if err := server.Start(); err != nil { + t.Fatal(err) + } + defer server.Stop() + + // Fill up all the slots on the server + dialer := &net.Dialer{Deadline: time.Now().Add(3 * time.Second)} + for i := 0; i < server.MaxPeers; i++ { + // Establish a new connection + conn, err := dialer.Dial("tcp", server.ListenAddr) + if err != nil { + t.Fatalf("conn %d: dial error: %v", i, err) + } + defer conn.Close() + + // Run the handshakes just like a real peer would, and wait for completion + key := newkey() + shake := &protoHandshake{Version: baseProtocolVersion, ID: discover.PubkeyID(&key.PublicKey)} + if _, err = setupConn(conn, key, shake, server.Self(), false, nil); err != nil { + t.Fatalf("conn %d: unexpected error: %v", i, err) + } + <-started + } + // Inject a trusted node and dial that (we'll connect from this end, don't need IP setup) + key := newkey() + trusted := &discover.Node{ + ID: discover.PubkeyID(&key.PublicKey), + } + server.TrustPeer(trusted) + + conn, err := dialer.Dial("tcp", server.ListenAddr) + if err != nil { + t.Fatalf("trusted node: dial error: %v", err) + } + defer conn.Close() + + shake := &protoHandshake{Version: baseProtocolVersion, ID: trusted.ID} + if _, err = setupConn(conn, key, shake, server.Self(), false, nil); err != nil { + t.Fatalf("trusted node: unexpected error: %v", err) + } + select { + case <-started: + // Ok, trusted peer accepted + + case <-time.After(100 * time.Millisecond): + t.Fatalf("trusted node timeout") + } +} + // Tests that a failed dial will temporarily throttle a peer. func TestServerOutboundThrottling(t *testing.T) { defer testlog(t).detach() @@ -298,7 +360,7 @@ func TestServerInboundThrottling(t *testing.T) { t.Fatalf("failed to dial server: %v", err) } shake := &protoHandshake{Version: baseProtocolVersion, ID: discover.PubkeyID(&key.PublicKey)} - if _, err = setupConn(connection, key, shake, server.Self(), false); err != nil { + if _, err = setupConn(connection, key, shake, server.Self(), false, nil); err != nil { t.Fatalf("failed to run handshake: %v", err) } <-started @@ -317,7 +379,7 @@ func TestServerInboundThrottling(t *testing.T) { defer connection.Close() shake = &protoHandshake{Version: baseProtocolVersion, ID: discover.PubkeyID(&key.PublicKey)} - if _, err = setupConn(connection, key, shake, server.Self(), false); err != nil { + if _, err = setupConn(connection, key, shake, server.Self(), false, nil); err != nil { t.Fatalf("failed to re-run handshake: %v", err) } select {