cmd/devp2p/internal/ethtest: add 'large announcement' tests

cmd/devp2p/internal/ethtest/large.go

@@ -0,0 +1,80 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package ethtest
+
+import (
+	"crypto/rand"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// largeNumber returns a very large big.Int.
+func largeNumber(megabytes int) *big.Int {
+	buf := make([]byte, megabytes*1024*1024)
+	rand.Read(buf)
+	bigint := new(big.Int)
+	bigint.SetBytes(buf)
+	return bigint
+}
+
+// largeBuffer returns a very large buffer.
+func largeBuffer(megabytes int) []byte {
+	buf := make([]byte, megabytes*1024*1024)
+	rand.Read(buf)
+	return buf
+}
+
+// largeString returns a very large string.
+func largeString(megabytes int) string {
+	buf := make([]byte, megabytes*1024*1024)
+	rand.Read(buf)
+	return hexutil.Encode(buf)
+}
+
+func largeBlock() *types.Block {
+	return types.NewBlockWithHeader(largeHeader())
+}
+
+// Returns a random hash
+func randHash() common.Hash {
+	var h common.Hash
+	rand.Read(h[:])
+	return h
+}
+
+func largeHeader() *types.Header {
+	return &types.Header{
+		MixDigest:   randHash(),
+		ReceiptHash: randHash(),
+		TxHash:      randHash(),
+		Nonce:       types.BlockNonce{},
+		Extra:       []byte{},
+		Bloom:       types.Bloom{},
+		GasUsed:     0,
+		Coinbase:    common.Address{},
+		GasLimit:    0,
+		UncleHash:   randHash(),
+		Time:        1337,
+		ParentHash:  randHash(),
+		Root:        randHash(),
+		Number:      largeNumber(2),
+		Difficulty:  largeNumber(2),
+	}
+}

cmd/devp2p/internal/ethtest/suite.go

@@ -24,6 +24,7 @@ import (
 	"github.com/davecgh/go-spew/spew"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/internal/utesting"
+	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/rlpx"
 	"github.com/stretchr/testify/assert"
@@ -66,6 +67,9 @@ func (s *Suite) AllTests() []utesting.Test {
 		{Name: "GetBlockHeaders", Fn: s.TestGetBlockHeaders},
 		{Name: "Broadcast", Fn: s.TestBroadcast},
 		{Name: "GetBlockBodies", Fn: s.TestGetBlockBodies},
+		{Name: "TestLargeAnnounce", Fn: s.TestLargeAnnounce},
+		{Name: "TestMaliciousHandshake", Fn: s.TestMaliciousHandshake},
+		{Name: "TestMaliciousStatus", Fn: s.TestMaliciousStatus},
 	}
 }
 
@@ -80,14 +84,40 @@ func (s *Suite) TestStatus(t *utesting.T) {
 	// get protoHandshake
 	conn.handshake(t)
 	// get status
-	switch msg := conn.statusExchange(t, s.chain).(type) {
+	switch msg := conn.statusExchange(t, s.chain, nil).(type) {
 	case *Status:
 		t.Logf("got status message: %s", pretty.Sdump(msg))
 	default:
 		t.Fatalf("unexpected: %s", pretty.Sdump(msg))
 	}
 }
 
+// TestMaliciousStatus sends a status package with a large total difficulty.
+func (s *Suite) TestMaliciousStatus(t *utesting.T) {
+	conn, err := s.dial()
+	if err != nil {
+		t.Fatalf("could not dial: %v", err)
+	}
+	// get protoHandshake
+	conn.handshake(t)
+	status := &Status{
+		ProtocolVersion: uint32(conn.ethProtocolVersion),
+		NetworkID:       s.chain.chainConfig.ChainID.Uint64(),
+		TD:              largeNumber(2),
+		Head:            s.chain.blocks[s.chain.Len()-1].Hash(),
+		Genesis:         s.chain.blocks[0].Hash(),
+		ForkID:          s.chain.ForkID(),
+	}
+	// get status
+	switch msg := conn.statusExchange(t, s.chain, status).(type) {
+	case *Status:
+		t.Logf("%+v\n", msg)
+	default:
+		t.Fatalf("unexpected: %#v", msg)
+	}
+	conn.waitForMessage(Disconnect{})
+}
+
 // TestGetBlockHeaders tests whether the given node can respond to
 // a `GetBlockHeaders` request and that the response is accurate.
 func (s *Suite) TestGetBlockHeaders(t *utesting.T) {
@@ -97,7 +127,7 @@ func (s *Suite) TestGetBlockHeaders(t *utesting.T) {
 	}
 
 	conn.handshake(t)
-	conn.statusExchange(t, s.chain)
+	conn.statusExchange(t, s.chain, nil)
 
 	// get block headers
 	req := &GetBlockHeaders{
@@ -136,7 +166,7 @@ func (s *Suite) TestGetBlockBodies(t *utesting.T) {
 	}
 
 	conn.handshake(t)
-	conn.statusExchange(t, s.chain)
+	conn.statusExchange(t, s.chain, nil)
 	// create block bodies request
 	req := &GetBlockBodies{s.chain.blocks[54].Hash(), s.chain.blocks[75].Hash()}
 	if err := conn.Write(req); err != nil {
@@ -155,34 +185,146 @@ func (s *Suite) TestGetBlockBodies(t *utesting.T) {
 // TestBroadcast tests whether a block announcement is correctly
 // propagated to the given node's peer(s).
 func (s *Suite) TestBroadcast(t *utesting.T) {
-	// create conn to send block announcement
-	sendConn, err := s.dial()
-	if err != nil {
-		t.Fatalf("could not dial: %v", err)
+	sendConn, receiveConn := s.setupConnection(t), s.setupConnection(t)
+	nextBlock := len(s.chain.blocks)
+	blockAnnouncement := &NewBlock{
+		Block: s.fullChain.blocks[nextBlock],
+		TD:    s.fullChain.TD(nextBlock + 1),
+	}
+	s.testAnnounce(t, sendConn, receiveConn, blockAnnouncement)
+	// update test suite chain
+	s.chain.blocks = append(s.chain.blocks, s.fullChain.blocks[nextBlock])
+	// wait for client to update its chain
+	if err := receiveConn.waitForBlock(s.chain.Head()); err != nil {
+		t.Fatal(err)
 	}
-	// create conn to receive block announcement
-	receiveConn, err := s.dial()
+}
+
+// TestMaliciousHandshake tries to send malicious data during the handshake.
+func (s *Suite) TestMaliciousHandshake(t *utesting.T) {
+	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("could not dial: %v", err)
 	}
+	// write hello to client
+	pub0 := crypto.FromECDSAPub(&conn.ourKey.PublicKey)[1:]
+	handshakes := []*Hello{
+		{
+			Version: 5,
+			Caps: []p2p.Cap{
+				{Name: largeString(2), Version: 64},
+			},
+			ID: pub0,
+		},
+		{
+			Version: 5,
+			Caps: []p2p.Cap{
+				{Name: "eth", Version: 64},
+				{Name: "eth", Version: 65},
+			},
+			ID: append(pub0, byte(0)),
+		},
+		{
+			Version: 5,
+			Caps: []p2p.Cap{
+				{Name: "eth", Version: 64},
+				{Name: "eth", Version: 65},
+			},
+			ID: append(pub0, pub0...),
+		},
+		{
+			Version: 5,
+			Caps: []p2p.Cap{
+				{Name: "eth", Version: 64},
+				{Name: "eth", Version: 65},
+			},
+			ID: largeBuffer(2),
+		},
+		{
+			Version: 5,
+			Caps: []p2p.Cap{
+				{Name: largeString(2), Version: 64},
+			},
+			ID: largeBuffer(2),
+		},
+	}
+	for _, handshake := range handshakes {
+		s.testDisconnect(t, conn, handshake)
+		// Dial for the next round
+		conn, err = s.dial()
+		if err != nil {
+			t.Fatalf("could not dial: %v", err)
+		}
+	}
+}
 
-	sendConn.handshake(t)
-	receiveConn.handshake(t)
+// TestLargeAnnounce tests the announcement mechanism with a large block.
+func (s *Suite) TestLargeAnnounce(t *utesting.T) {
+	nextBlock := len(s.chain.blocks)
+	blocks := []*NewBlock{
+		{
+			Block: largeBlock(),
+			TD:    s.fullChain.TD(nextBlock + 1),
+		},
+		{
+			Block: s.fullChain.blocks[nextBlock],
+			TD:    largeNumber(2),
+		},
+		{
+			Block: largeBlock(),
+			TD:    largeNumber(2),
+		},
+		{
+			Block: s.fullChain.blocks[nextBlock],
+			TD:    s.fullChain.TD(nextBlock + 1),
+		},
+	}
 
-	sendConn.statusExchange(t, s.chain)
-	receiveConn.statusExchange(t, s.chain)
+	var receiveConn *Conn
+	for i, blockAnnouncement := range blocks {
+		sendConn := s.setupConnection(t)
+		if i == 3 {
+			receiveConn = s.setupConnection(t)
+			// The third block is a valid block
+			if err := sendConn.Write(blockAnnouncement); err != nil {
+				t.Fatalf("could not write to connection: %v", err)
+			}
+		} else {
+			s.testDisconnect(t, sendConn, blockAnnouncement)
+		}
+	}
+	s.waitAnnounce(t, receiveConn, blocks[3])
+	// update test suite chain
+	s.chain.blocks = append(s.chain.blocks, s.fullChain.blocks[nextBlock])
+	// wait for client to update its chain
+	if err := receiveConn.waitForBlock(s.fullChain.blocks[nextBlock]); err != nil {
+		t.Fatal(err)
+	}
+}
 
-	// sendConn sends the block announcement
-	blockAnnouncement := &NewBlock{
-		Block: s.fullChain.blocks[1000],
-		TD:    s.fullChain.TD(1001),
+func (s *Suite) testDisconnect(t *utesting.T, conn *Conn, msg Message) {
+	// Announce the block.
+	if err := conn.Write(msg); err != nil {
+		t.Fatalf("could not write to connection: %v", err)
+	}
+	time.Sleep(100 * time.Millisecond)
+	// check that the peer disconnected
+	if err := conn.waitForMessage(Disconnect{}); err != nil {
+		t.Fatalf("connection was not disconnected: %v", err)
 	}
+}
+
+func (s *Suite) testAnnounce(t *utesting.T, sendConn, receiveConn *Conn, blockAnnouncement *NewBlock) {
+	// Announce the block.
 	if err := sendConn.Write(blockAnnouncement); err != nil {
 		t.Fatalf("could not write to connection: %v", err)
 	}
+	s.waitAnnounce(t, receiveConn, blockAnnouncement)
+}
 
+func (s *Suite) waitAnnounce(t *utesting.T, conn *Conn, blockAnnouncement *NewBlock) {
 	timeout := 20 * time.Second
-	switch msg := receiveConn.ReadAndServe(s.chain, timeout).(type) {
+	switch msg := conn.ReadAndServe(s.chain, timeout).(type) {
 	case *NewBlock:
 		t.Logf("received NewBlock message: %s", pretty.Sdump(msg.Block))
 		assert.Equal(t,
@@ -203,12 +345,17 @@ func (s *Suite) TestBroadcast(t *utesting.T) {
 	default:
 		t.Fatalf("unexpected: %s", pretty.Sdump(msg))
 	}
-	// update test suite chain
-	s.chain.blocks = append(s.chain.blocks, s.fullChain.blocks[1000])
-	// wait for client to update its chain
-	if err := receiveConn.waitForBlock(s.chain.Head()); err != nil {
-		t.Fatal(err)
+}
+
+func (s *Suite) setupConnection(t *utesting.T) *Conn {
+	// create conn
+	sendConn, err := s.dial()
+	if err != nil {
+		t.Fatalf("could not dial: %v", err)
 	}
+	sendConn.handshake(t)
+	sendConn.statusExchange(t, s.chain, nil)
+	return sendConn
 }
 
 // dial attempts to dial the given node and perform a handshake,