github.com/fff-chain/go-fff@v0.0.0-20220726032732-1c84420b8a99/p2p/server_test.go (about) 1 // Copyright 2014 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package p2p 18 19 import ( 20 "crypto/ecdsa" 21 "crypto/sha256" 22 "errors" 23 "io" 24 "math/rand" 25 "net" 26 "reflect" 27 "testing" 28 "time" 29 30 "github.com/fff-chain/go-fff/crypto" 31 "github.com/fff-chain/go-fff/internal/testlog" 32 "github.com/fff-chain/go-fff/log" 33 "github.com/fff-chain/go-fff/p2p/enode" 34 "github.com/fff-chain/go-fff/p2p/enr" 35 "github.com/fff-chain/go-fff/p2p/rlpx" 36 ) 37 38 type testTransport struct { 39 *rlpxTransport 40 rpub *ecdsa.PublicKey 41 closeErr error 42 } 43 44 func newTestTransport(rpub *ecdsa.PublicKey, fd net.Conn, dialDest *ecdsa.PublicKey) transport { 45 wrapped := newRLPX(fd, dialDest).(*rlpxTransport) 46 wrapped.conn.InitWithSecrets(rlpx.Secrets{ 47 AES: make([]byte, 16), 48 MAC: make([]byte, 16), 49 EgressMAC: sha256.New(), 50 IngressMAC: sha256.New(), 51 }) 52 return &testTransport{rpub: rpub, rlpxTransport: wrapped} 53 } 54 55 func (c *testTransport) doEncHandshake(prv *ecdsa.PrivateKey) (*ecdsa.PublicKey, error) { 56 return c.rpub, nil 57 } 58 59 func (c *testTransport) doProtoHandshake(our *protoHandshake) (*protoHandshake, error) { 60 pubkey := crypto.FromECDSAPub(c.rpub)[1:] 61 return &protoHandshake{ID: pubkey, Name: "test"}, nil 62 } 63 64 func (c *testTransport) close(err error) { 65 c.conn.Close() 66 c.closeErr = err 67 } 68 69 func startTestServer(t *testing.T, remoteKey *ecdsa.PublicKey, pf func(*Peer)) *Server { 70 config := Config{ 71 Name: "test", 72 MaxPeers: 10, 73 ListenAddr: "127.0.0.1:0", 74 NoDiscovery: true, 75 PrivateKey: newkey(), 76 Logger: testlog.Logger(t, log.LvlTrace), 77 } 78 server := &Server{ 79 Config: config, 80 newPeerHook: pf, 81 newTransport: func(fd net.Conn, dialDest *ecdsa.PublicKey) transport { 82 return newTestTransport(remoteKey, fd, dialDest) 83 }, 84 } 85 if err := server.Start(); err != nil { 86 t.Fatalf("Could not start server: %v", err) 87 } 88 return server 89 } 90 91 func TestServerListen(t *testing.T) { 92 // start the test server 93 connected := make(chan *Peer) 94 remid := &newkey().PublicKey 95 srv := startTestServer(t, remid, func(p *Peer) { 96 if p.ID() != enode.PubkeyToIDV4(remid) { 97 t.Error("peer func called with wrong node id") 98 } 99 connected <- p 100 }) 101 defer close(connected) 102 defer srv.Stop() 103 104 // dial the test server 105 conn, err := net.DialTimeout("tcp", srv.ListenAddr, 5*time.Second) 106 if err != nil { 107 t.Fatalf("could not dial: %v", err) 108 } 109 defer conn.Close() 110 111 select { 112 case peer := <-connected: 113 if peer.LocalAddr().String() != conn.RemoteAddr().String() { 114 t.Errorf("peer started with wrong conn: got %v, want %v", 115 peer.LocalAddr(), conn.RemoteAddr()) 116 } 117 peers := srv.Peers() 118 if !reflect.DeepEqual(peers, []*Peer{peer}) { 119 t.Errorf("Peers mismatch: got %v, want %v", peers, []*Peer{peer}) 120 } 121 case <-time.After(1 * time.Second): 122 t.Error("server did not accept within one second") 123 } 124 } 125 126 func TestServerDial(t *testing.T) { 127 // run a one-shot TCP server to handle the connection. 128 listener, err := net.Listen("tcp", "127.0.0.1:0") 129 if err != nil { 130 t.Fatalf("could not setup listener: %v", err) 131 } 132 defer listener.Close() 133 accepted := make(chan net.Conn, 1) 134 go func() { 135 conn, err := listener.Accept() 136 if err != nil { 137 return 138 } 139 accepted <- conn 140 }() 141 142 // start the server 143 connected := make(chan *Peer) 144 remid := &newkey().PublicKey 145 srv := startTestServer(t, remid, func(p *Peer) { connected <- p }) 146 defer close(connected) 147 defer srv.Stop() 148 149 // tell the server to connect 150 tcpAddr := listener.Addr().(*net.TCPAddr) 151 node := enode.NewV4(remid, tcpAddr.IP, tcpAddr.Port, 0) 152 srv.AddPeer(node) 153 154 select { 155 case conn := <-accepted: 156 defer conn.Close() 157 158 select { 159 case peer := <-connected: 160 if peer.ID() != enode.PubkeyToIDV4(remid) { 161 t.Errorf("peer has wrong id") 162 } 163 if peer.Name() != "test" { 164 t.Errorf("peer has wrong name") 165 } 166 if peer.RemoteAddr().String() != conn.LocalAddr().String() { 167 t.Errorf("peer started with wrong conn: got %v, want %v", 168 peer.RemoteAddr(), conn.LocalAddr()) 169 } 170 peers := srv.Peers() 171 if !reflect.DeepEqual(peers, []*Peer{peer}) { 172 t.Errorf("Peers mismatch: got %v, want %v", peers, []*Peer{peer}) 173 } 174 175 // Test AddTrustedPeer/RemoveTrustedPeer and changing Trusted flags 176 // Particularly for race conditions on changing the flag state. 177 if peer := srv.Peers()[0]; peer.Info().Network.Trusted { 178 t.Errorf("peer is trusted prematurely: %v", peer) 179 } 180 done := make(chan bool) 181 go func() { 182 srv.AddTrustedPeer(node) 183 if peer := srv.Peers()[0]; !peer.Info().Network.Trusted { 184 t.Errorf("peer is not trusted after AddTrustedPeer: %v", peer) 185 } 186 srv.RemoveTrustedPeer(node) 187 if peer := srv.Peers()[0]; peer.Info().Network.Trusted { 188 t.Errorf("peer is trusted after RemoveTrustedPeer: %v", peer) 189 } 190 done <- true 191 }() 192 // Trigger potential race conditions 193 peer = srv.Peers()[0] 194 _ = peer.Inbound() 195 _ = peer.Info() 196 <-done 197 case <-time.After(1 * time.Second): 198 t.Error("server did not launch peer within one second") 199 } 200 201 case <-time.After(1 * time.Second): 202 t.Error("server did not connect within one second") 203 } 204 } 205 206 func TestServerStopTimeout(t *testing.T) { 207 srv := &Server{Config: Config{ 208 PrivateKey: newkey(), 209 MaxPeers: 1, 210 NoDiscovery: true, 211 Logger: testlog.Logger(t, log.LvlTrace).New("server", "1"), 212 }} 213 srv.Start() 214 srv.loopWG.Add(1) 215 216 stopChan := make(chan struct{}) 217 go func() { 218 srv.Stop() 219 close(stopChan) 220 }() 221 222 select { 223 case <-stopChan: 224 case <-time.After(10 * time.Second): 225 t.Error("server should be shutdown in 10 seconds") 226 } 227 } 228 229 // This test checks that RemovePeer disconnects the peer if it is connected. 230 func TestServerRemovePeerDisconnect(t *testing.T) { 231 srv1 := &Server{Config: Config{ 232 PrivateKey: newkey(), 233 MaxPeers: 1, 234 NoDiscovery: true, 235 Logger: testlog.Logger(t, log.LvlTrace).New("server", "1"), 236 }} 237 srv2 := &Server{Config: Config{ 238 PrivateKey: newkey(), 239 MaxPeers: 1, 240 NoDiscovery: true, 241 NoDial: true, 242 ListenAddr: "127.0.0.1:0", 243 Logger: testlog.Logger(t, log.LvlTrace).New("server", "2"), 244 }} 245 srv1.Start() 246 defer srv1.Stop() 247 srv2.Start() 248 defer srv2.Stop() 249 250 if !syncAddPeer(srv1, srv2.Self()) { 251 t.Fatal("peer not connected") 252 } 253 srv1.RemovePeer(srv2.Self()) 254 if srv1.PeerCount() > 0 { 255 t.Fatal("removed peer still connected") 256 } 257 } 258 259 // This test checks that connections are disconnected just after the encryption handshake 260 // when the server is at capacity. Trusted connections should still be accepted. 261 func TestServerAtCap(t *testing.T) { 262 trustedNode := newkey() 263 trustedID := enode.PubkeyToIDV4(&trustedNode.PublicKey) 264 srv := &Server{ 265 Config: Config{ 266 PrivateKey: newkey(), 267 MaxPeers: 10, 268 NoDial: true, 269 NoDiscovery: true, 270 TrustedNodes: []*enode.Node{newNode(trustedID, "")}, 271 Logger: testlog.Logger(t, log.LvlTrace), 272 }, 273 } 274 if err := srv.Start(); err != nil { 275 t.Fatalf("could not start: %v", err) 276 } 277 defer srv.Stop() 278 279 newconn := func(id enode.ID) *conn { 280 fd, _ := net.Pipe() 281 tx := newTestTransport(&trustedNode.PublicKey, fd, nil) 282 node := enode.SignNull(new(enr.Record), id) 283 return &conn{fd: fd, transport: tx, flags: inboundConn, node: node, cont: make(chan error)} 284 } 285 286 // Inject a few connections to fill up the peer set. 287 for i := 0; i < 10; i++ { 288 c := newconn(randomID()) 289 if err := srv.checkpoint(c, srv.checkpointAddPeer); err != nil { 290 t.Fatalf("could not add conn %d: %v", i, err) 291 } 292 } 293 // Try inserting a non-trusted connection. 294 anotherID := randomID() 295 c := newconn(anotherID) 296 if err := srv.checkpoint(c, srv.checkpointPostHandshake); err != DiscTooManyPeers { 297 t.Error("wrong error for insert:", err) 298 } 299 // Try inserting a trusted connection. 300 c = newconn(trustedID) 301 if err := srv.checkpoint(c, srv.checkpointPostHandshake); err != nil { 302 t.Error("unexpected error for trusted conn @posthandshake:", err) 303 } 304 if !c.is(trustedConn) { 305 t.Error("Server did not set trusted flag") 306 } 307 308 // Remove from trusted set and try again 309 srv.RemoveTrustedPeer(newNode(trustedID, "")) 310 c = newconn(trustedID) 311 if err := srv.checkpoint(c, srv.checkpointPostHandshake); err != DiscTooManyPeers { 312 t.Error("wrong error for insert:", err) 313 } 314 315 // Add anotherID to trusted set and try again 316 srv.AddTrustedPeer(newNode(anotherID, "")) 317 c = newconn(anotherID) 318 if err := srv.checkpoint(c, srv.checkpointPostHandshake); err != nil { 319 t.Error("unexpected error for trusted conn @posthandshake:", err) 320 } 321 if !c.is(trustedConn) { 322 t.Error("Server did not set trusted flag") 323 } 324 } 325 326 func TestServerPeerLimits(t *testing.T) { 327 srvkey := newkey() 328 clientkey := newkey() 329 clientnode := enode.NewV4(&clientkey.PublicKey, nil, 0, 0) 330 331 var tp = &setupTransport{ 332 pubkey: &clientkey.PublicKey, 333 phs: protoHandshake{ 334 ID: crypto.FromECDSAPub(&clientkey.PublicKey)[1:], 335 // Force "DiscUselessPeer" due to unmatching caps 336 // Caps: []Cap{discard.cap()}, 337 }, 338 } 339 340 srv := &Server{ 341 Config: Config{ 342 PrivateKey: srvkey, 343 MaxPeers: 0, 344 NoDial: true, 345 NoDiscovery: true, 346 Protocols: []Protocol{discard}, 347 Logger: testlog.Logger(t, log.LvlTrace), 348 }, 349 newTransport: func(fd net.Conn, dialDest *ecdsa.PublicKey) transport { return tp }, 350 } 351 if err := srv.Start(); err != nil { 352 t.Fatalf("couldn't start server: %v", err) 353 } 354 defer srv.Stop() 355 356 // Check that server is full (MaxPeers=0) 357 flags := dynDialedConn 358 dialDest := clientnode 359 conn, _ := net.Pipe() 360 srv.SetupConn(conn, flags, dialDest) 361 if tp.closeErr != DiscTooManyPeers { 362 t.Errorf("unexpected close error: %q", tp.closeErr) 363 } 364 conn.Close() 365 366 srv.AddTrustedPeer(clientnode) 367 368 // Check that server allows a trusted peer despite being full. 369 conn, _ = net.Pipe() 370 srv.SetupConn(conn, flags, dialDest) 371 if tp.closeErr == DiscTooManyPeers { 372 t.Errorf("failed to bypass MaxPeers with trusted node: %q", tp.closeErr) 373 } 374 375 if tp.closeErr != DiscUselessPeer { 376 t.Errorf("unexpected close error: %q", tp.closeErr) 377 } 378 conn.Close() 379 380 srv.RemoveTrustedPeer(clientnode) 381 382 // Check that server is full again. 383 conn, _ = net.Pipe() 384 srv.SetupConn(conn, flags, dialDest) 385 if tp.closeErr != DiscTooManyPeers { 386 t.Errorf("unexpected close error: %q", tp.closeErr) 387 } 388 conn.Close() 389 } 390 391 func TestServerSetupConn(t *testing.T) { 392 var ( 393 clientkey, srvkey = newkey(), newkey() 394 clientpub = &clientkey.PublicKey 395 srvpub = &srvkey.PublicKey 396 ) 397 tests := []struct { 398 dontstart bool 399 tt *setupTransport 400 flags connFlag 401 dialDest *enode.Node 402 403 wantCloseErr error 404 wantCalls string 405 }{ 406 { 407 dontstart: true, 408 tt: &setupTransport{pubkey: clientpub}, 409 wantCalls: "close,", 410 wantCloseErr: errServerStopped, 411 }, 412 { 413 tt: &setupTransport{pubkey: clientpub, encHandshakeErr: errors.New("read error")}, 414 flags: inboundConn, 415 wantCalls: "doEncHandshake,close,", 416 wantCloseErr: errors.New("read error"), 417 }, 418 { 419 tt: &setupTransport{pubkey: clientpub, phs: protoHandshake{ID: randomID().Bytes()}}, 420 dialDest: enode.NewV4(clientpub, nil, 0, 0), 421 flags: dynDialedConn, 422 wantCalls: "doEncHandshake,doProtoHandshake,close,", 423 wantCloseErr: DiscUnexpectedIdentity, 424 }, 425 { 426 tt: &setupTransport{pubkey: clientpub, protoHandshakeErr: errors.New("foo")}, 427 dialDest: enode.NewV4(clientpub, nil, 0, 0), 428 flags: dynDialedConn, 429 wantCalls: "doEncHandshake,doProtoHandshake,close,", 430 wantCloseErr: errors.New("foo"), 431 }, 432 { 433 tt: &setupTransport{pubkey: srvpub, phs: protoHandshake{ID: crypto.FromECDSAPub(srvpub)[1:]}}, 434 flags: inboundConn, 435 wantCalls: "doEncHandshake,close,", 436 wantCloseErr: DiscSelf, 437 }, 438 { 439 tt: &setupTransport{pubkey: clientpub, phs: protoHandshake{ID: crypto.FromECDSAPub(clientpub)[1:]}}, 440 flags: inboundConn, 441 wantCalls: "doEncHandshake,doProtoHandshake,close,", 442 wantCloseErr: DiscUselessPeer, 443 }, 444 } 445 446 for i, test := range tests { 447 t.Run(test.wantCalls, func(t *testing.T) { 448 cfg := Config{ 449 PrivateKey: srvkey, 450 MaxPeers: 10, 451 NoDial: true, 452 NoDiscovery: true, 453 Protocols: []Protocol{discard}, 454 Logger: testlog.Logger(t, log.LvlTrace), 455 } 456 srv := &Server{ 457 Config: cfg, 458 newTransport: func(fd net.Conn, dialDest *ecdsa.PublicKey) transport { return test.tt }, 459 log: cfg.Logger, 460 } 461 if !test.dontstart { 462 if err := srv.Start(); err != nil { 463 t.Fatalf("couldn't start server: %v", err) 464 } 465 defer srv.Stop() 466 } 467 p1, _ := net.Pipe() 468 srv.SetupConn(p1, test.flags, test.dialDest) 469 if !reflect.DeepEqual(test.tt.closeErr, test.wantCloseErr) { 470 t.Errorf("test %d: close error mismatch: got %q, want %q", i, test.tt.closeErr, test.wantCloseErr) 471 } 472 if test.tt.calls != test.wantCalls { 473 t.Errorf("test %d: calls mismatch: got %q, want %q", i, test.tt.calls, test.wantCalls) 474 } 475 }) 476 } 477 } 478 479 type setupTransport struct { 480 pubkey *ecdsa.PublicKey 481 encHandshakeErr error 482 phs protoHandshake 483 protoHandshakeErr error 484 485 calls string 486 closeErr error 487 } 488 489 func (c *setupTransport) doEncHandshake(prv *ecdsa.PrivateKey) (*ecdsa.PublicKey, error) { 490 c.calls += "doEncHandshake," 491 return c.pubkey, c.encHandshakeErr 492 } 493 494 func (c *setupTransport) doProtoHandshake(our *protoHandshake) (*protoHandshake, error) { 495 c.calls += "doProtoHandshake," 496 if c.protoHandshakeErr != nil { 497 return nil, c.protoHandshakeErr 498 } 499 return &c.phs, nil 500 } 501 func (c *setupTransport) close(err error) { 502 c.calls += "close," 503 c.closeErr = err 504 } 505 506 // setupConn shouldn't write to/read from the connection. 507 func (c *setupTransport) WriteMsg(Msg) error { 508 panic("WriteMsg called on setupTransport") 509 } 510 func (c *setupTransport) ReadMsg() (Msg, error) { 511 panic("ReadMsg called on setupTransport") 512 } 513 514 func newkey() *ecdsa.PrivateKey { 515 key, err := crypto.GenerateKey() 516 if err != nil { 517 panic("couldn't generate key: " + err.Error()) 518 } 519 return key 520 } 521 522 func randomID() (id enode.ID) { 523 for i := range id { 524 id[i] = byte(rand.Intn(255)) 525 } 526 return id 527 } 528 529 // This test checks that inbound connections are throttled by IP. 530 func TestServerInboundThrottle(t *testing.T) { 531 const timeout = 5 * time.Second 532 newTransportCalled := make(chan struct{}) 533 srv := &Server{ 534 Config: Config{ 535 PrivateKey: newkey(), 536 ListenAddr: "127.0.0.1:0", 537 MaxPeers: 10, 538 NoDial: true, 539 NoDiscovery: true, 540 Protocols: []Protocol{discard}, 541 Logger: testlog.Logger(t, log.LvlTrace), 542 }, 543 newTransport: func(fd net.Conn, dialDest *ecdsa.PublicKey) transport { 544 newTransportCalled <- struct{}{} 545 return newRLPX(fd, dialDest) 546 }, 547 listenFunc: func(network, laddr string) (net.Listener, error) { 548 fakeAddr := &net.TCPAddr{IP: net.IP{95, 33, 21, 2}, Port: 4444} 549 return listenFakeAddr(network, laddr, fakeAddr) 550 }, 551 } 552 if err := srv.Start(); err != nil { 553 t.Fatal("can't start: ", err) 554 } 555 defer srv.Stop() 556 557 // Dial the test server. 558 conn, err := net.DialTimeout("tcp", srv.ListenAddr, timeout) 559 if err != nil { 560 t.Fatalf("could not dial: %v", err) 561 } 562 select { 563 case <-newTransportCalled: 564 // OK 565 case <-time.After(timeout): 566 t.Error("newTransport not called") 567 } 568 conn.Close() 569 570 // Dial again. This time the server should close the connection immediately. 571 connClosed := make(chan struct{}, 1) 572 conn, err = net.DialTimeout("tcp", srv.ListenAddr, timeout) 573 if err != nil { 574 t.Fatalf("could not dial: %v", err) 575 } 576 defer conn.Close() 577 go func() { 578 conn.SetDeadline(time.Now().Add(timeout)) 579 buf := make([]byte, 10) 580 if n, err := conn.Read(buf); err != io.EOF || n != 0 { 581 t.Errorf("expected io.EOF and n == 0, got error %q and n == %d", err, n) 582 } 583 connClosed <- struct{}{} 584 }() 585 select { 586 case <-connClosed: 587 // OK 588 case <-newTransportCalled: 589 t.Error("newTransport called for second attempt") 590 case <-time.After(timeout): 591 t.Error("connection not closed within timeout") 592 } 593 } 594 595 func listenFakeAddr(network, laddr string, remoteAddr net.Addr) (net.Listener, error) { 596 l, err := net.Listen(network, laddr) 597 if err == nil { 598 l = &fakeAddrListener{l, remoteAddr} 599 } 600 return l, err 601 } 602 603 // fakeAddrListener is a listener that creates connections with a mocked remote address. 604 type fakeAddrListener struct { 605 net.Listener 606 remoteAddr net.Addr 607 } 608 609 type fakeAddrConn struct { 610 net.Conn 611 remoteAddr net.Addr 612 } 613 614 func (l *fakeAddrListener) Accept() (net.Conn, error) { 615 c, err := l.Listener.Accept() 616 if err != nil { 617 return nil, err 618 } 619 return &fakeAddrConn{c, l.remoteAddr}, nil 620 } 621 622 func (c *fakeAddrConn) RemoteAddr() net.Addr { 623 return c.remoteAddr 624 } 625 626 func syncAddPeer(srv *Server, node *enode.Node) bool { 627 var ( 628 ch = make(chan *PeerEvent) 629 sub = srv.SubscribeEvents(ch) 630 timeout = time.After(2 * time.Second) 631 ) 632 defer sub.Unsubscribe() 633 srv.AddPeer(node) 634 for { 635 select { 636 case ev := <-ch: 637 if ev.Type == PeerEventTypeAdd && ev.Peer == node.ID() { 638 return true 639 } 640 case <-timeout: 641 return false 642 } 643 } 644 }