Merge pull request #146 from getamis/feature/avoid_bad_block

markya0616 · web-flow · commit 868570b19602 · 2017-09-01T02:58:39.000-05:00
avoid bad block
diff --git a/consensus/consensus.go b/consensus/consensus.go
@@ -121,7 +121,7 @@ type Istanbul interface {
 	Engine
 
 	// Start starts the engine
-	Start(chain ChainReader, currentBlock func() *types.Block) error
+	Start(chain ChainReader, currentBlock func() *types.Block, hasBadBlock func(hash common.Hash) bool) error
 
 	// Stop stops the engine
 	Stop() error
diff --git a/consensus/istanbul/backend.go b/consensus/istanbul/backend.go
@@ -67,4 +67,7 @@ type Backend interface {
 
 	// ParentValidators returns the validator set of the given proposal's parent block
 	ParentValidators(proposal Proposal) ValidatorSet
+
+	// HasBadBlock returns whether the block with the hash is a bad block
+	HasBadProposal(hash common.Hash) bool
 }
diff --git a/consensus/istanbul/backend/backend.go b/consensus/istanbul/backend/backend.go
@@ -27,6 +27,7 @@ import (
 	"github.com/ethereum/go-ethereum/consensus/istanbul"
 	istanbulCore "github.com/ethereum/go-ethereum/consensus/istanbul/core"
 	"github.com/ethereum/go-ethereum/consensus/istanbul/validator"
+	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
@@ -76,6 +77,7 @@ type backend struct {
 	db               ethdb.Database
 	chain            consensus.ChainReader
 	currentBlock     func() *types.Block
+	hasBadBlock      func(hash common.Hash) bool
 
 	// the channels for istanbul engine notifications
 	commitCh          chan *types.Block
@@ -208,6 +210,22 @@ func (sb *backend) Verify(proposal istanbul.Proposal) (time.Duration, error) {
 		sb.logger.Error("Invalid proposal, %v", proposal)
 		return 0, errInvalidProposal
 	}
+
+	// check bad block
+	if sb.HasBadProposal(block.Hash()) {
+		return 0, core.ErrBlacklistedHash
+	}
+
+	// check block body
+	txnHash := types.DeriveSha(block.Transactions())
+	uncleHash := types.CalcUncleHash(block.Uncles())
+	if txnHash != block.Header().TxHash {
+		return 0, errMismatchTxhashes
+	}
+	if uncleHash != nilUncleHash {
+		return 0, errInvalidUncleHash
+	}
+
 	// verify the header of proposed block
 	err := sb.VerifyHeader(sb.chain, block.Header(), false)
 	// ignore errEmptyCommittedSeals error because we don't have the committed seals yet
@@ -285,3 +303,10 @@ func (sb *backend) LastProposal() (istanbul.Proposal, common.Address) {
 	// Return header only block here since we don't need block body
 	return block, proposer
 }
+
+func (sb *backend) HasBadProposal(hash common.Hash) bool {
+	if sb.hasBadBlock == nil {
+		return false
+	}
+	return sb.hasBadBlock(hash)
+}
diff --git a/consensus/istanbul/backend/engine.go b/consensus/istanbul/backend/engine.go
@@ -80,6 +80,8 @@ var (
 	errInvalidCommittedSeals = errors.New("invalid committed seals")
 	// errEmptyCommittedSeals is returned if the field of committed seals is zero.
 	errEmptyCommittedSeals = errors.New("zero committed seals")
+	// errMismatchTxhashes is returned if the TxHash in header is mismatch.
+	errMismatchTxhashes = errors.New("mismatch transcations hashes")
 )
 var (
 	defaultDifficulty = big.NewInt(1)
@@ -485,7 +487,7 @@ func (sb *backend) APIs(chain consensus.ChainReader) []rpc.API {
 }
 
 // Start implements consensus.Istanbul.Start
-func (sb *backend) Start(chain consensus.ChainReader, currentBlock func() *types.Block) error {
+func (sb *backend) Start(chain consensus.ChainReader, currentBlock func() *types.Block, hasBadBlock func(hash common.Hash) bool) error {
 	sb.coreMu.Lock()
 	defer sb.coreMu.Unlock()
 	if sb.coreStarted {
@@ -501,6 +503,7 @@ func (sb *backend) Start(chain consensus.ChainReader, currentBlock func() *types
 
 	sb.chain = chain
 	sb.currentBlock = currentBlock
+	sb.hasBadBlock = hasBadBlock
 
 	if err := sb.core.Start(); err != nil {
 		return err
diff --git a/consensus/istanbul/backend/engine_test.go b/consensus/istanbul/backend/engine_test.go
@@ -51,7 +51,7 @@ func newBlockChain(n int) (*core.BlockChain, *backend) {
 	if err != nil {
 		panic(err)
 	}
-	b.Start(blockchain, blockchain.CurrentBlock)
+	b.Start(blockchain, blockchain.CurrentBlock, blockchain.HasBadBlock)
 	snap, err := b.snapshot(blockchain, 0, common.Hash{}, nil)
 	if err != nil {
 		panic(err)
diff --git a/consensus/istanbul/core/backlog_test.go b/consensus/istanbul/core/backlog_test.go
@@ -37,7 +37,7 @@ func TestCheckMessage(t *testing.T) {
 		current: newRoundState(&istanbul.View{
 			Sequence: big.NewInt(1),
 			Round:    big.NewInt(0),
-		}, newTestValidatorSet(4), common.Hash{}, nil, nil),
+		}, newTestValidatorSet(4), common.Hash{}, nil, nil, nil),
 	}
 
 	// invalid view format
@@ -209,7 +209,7 @@ func TestProcessFutureBacklog(t *testing.T) {
 		current: newRoundState(&istanbul.View{
 			Sequence: big.NewInt(1),
 			Round:    big.NewInt(0),
-		}, newTestValidatorSet(4), common.Hash{}, nil, nil),
+		}, newTestValidatorSet(4), common.Hash{}, nil, nil, nil),
 		state: StateAcceptRequest,
 	}
 	c.subscribeEvents()
@@ -297,7 +297,7 @@ func testProcessBacklog(t *testing.T, msg *message) {
 		current: newRoundState(&istanbul.View{
 			Sequence: big.NewInt(1),
 			Round:    big.NewInt(0),
-		}, newTestValidatorSet(4), common.Hash{}, nil, nil),
+		}, newTestValidatorSet(4), common.Hash{}, nil, nil, nil),
 	}
 	c.subscribeEvents()
 	defer c.unsubscribeEvents()
diff --git a/consensus/istanbul/core/core.go b/consensus/istanbul/core/core.go
@@ -276,12 +276,12 @@ func (c *core) updateRoundState(view *istanbul.View, validatorSet istanbul.Valid
 	// Lock only if both roundChange is true and it is locked
 	if roundChange && c.current != nil {
 		if c.current.IsHashLocked() {
-			c.current = newRoundState(view, validatorSet, c.current.GetLockedHash(), c.current.Preprepare, c.current.pendingRequest)
+			c.current = newRoundState(view, validatorSet, c.current.GetLockedHash(), c.current.Preprepare, c.current.pendingRequest, c.backend.HasBadProposal)
 		} else {
-			c.current = newRoundState(view, validatorSet, common.Hash{}, nil, c.current.pendingRequest)
+			c.current = newRoundState(view, validatorSet, common.Hash{}, nil, c.current.pendingRequest, c.backend.HasBadProposal)
 		}
 	} else {
-		c.current = newRoundState(view, validatorSet, common.Hash{}, nil, nil)
+		c.current = newRoundState(view, validatorSet, common.Hash{}, nil, nil, c.backend.HasBadProposal)
 	}
 }
 
diff --git a/consensus/istanbul/core/final_committed.go b/consensus/istanbul/core/final_committed.go
@@ -19,7 +19,7 @@ package core
 import "github.com/ethereum/go-ethereum/common"
 
 func (c *core) handleFinalCommitted() error {
-	logger := c.logger.New("state", c.state, "number")
+	logger := c.logger.New("state", c.state)
 	logger.Trace("Received a final committed proposal")
 	c.startNewRound(common.Big0)
 	return nil
diff --git a/consensus/istanbul/core/prepare.go b/consensus/istanbul/core/prepare.go
@@ -59,7 +59,8 @@ func (c *core) handlePrepare(msg *message, src istanbul.Validator) error {
 
 	// Change to Prepared state if we've received enough PREPARE messages or it is locked
 	// and we are in earlier state before Prepared state.
-	if (c.current.IsHashLocked() || c.current.GetPrepareOrCommitSize() > 2*c.valSet.F()) && c.state.Cmp(StatePrepared) < 0 {
+	if ((c.current.IsHashLocked() && prepare.Digest == c.current.GetLockedHash()) || c.current.Prepares.Size() > 2*c.valSet.F()) &&
+		c.state.Cmp(StatePrepared) < 0 {
 		c.current.LockHash()
 		c.setState(StatePrepared)
 		c.sendCommit()
diff --git a/consensus/istanbul/core/request_test.go b/consensus/istanbul/core/request_test.go
@@ -36,7 +36,7 @@ func TestCheckRequestMsg(t *testing.T) {
 		current: newRoundState(&istanbul.View{
 			Sequence: big.NewInt(1),
 			Round:    big.NewInt(0),
-		}, newTestValidatorSet(4), common.Hash{}, nil, nil),
+		}, newTestValidatorSet(4), common.Hash{}, nil, nil, nil),
 	}
 
 	// invalid request
@@ -91,7 +91,7 @@ func TestStoreRequestMsg(t *testing.T) {
 		current: newRoundState(&istanbul.View{
 			Sequence: big.NewInt(0),
 			Round:    big.NewInt(0),
-		}, newTestValidatorSet(4), common.Hash{}, nil, nil),
+		}, newTestValidatorSet(4), common.Hash{}, nil, nil, nil),
 		pendingRequests:   prque.New(),
 		pendingRequestsMu: new(sync.Mutex),
 	}
diff --git a/consensus/istanbul/core/roundstate.go b/consensus/istanbul/core/roundstate.go
@@ -29,7 +29,7 @@ import (
 // newRoundState creates a new roundState instance with the given view and validatorSet
 // lockedHash and preprepare are for round change when lock exists,
 // we need to keep a reference of preprepare in order to propose locked proposal when there is a lock and itself is the proposer
-func newRoundState(view *istanbul.View, validatorSet istanbul.ValidatorSet, lockedHash common.Hash, preprepare *istanbul.Preprepare, pendingRequest *istanbul.Request) *roundState {
+func newRoundState(view *istanbul.View, validatorSet istanbul.ValidatorSet, lockedHash common.Hash, preprepare *istanbul.Preprepare, pendingRequest *istanbul.Request, hasBadProposal func(hash common.Hash) bool) *roundState {
 	return &roundState{
 		round:          view.Round,
 		sequence:       view.Sequence,
@@ -39,6 +39,7 @@ func newRoundState(view *istanbul.View, validatorSet istanbul.ValidatorSet, lock
 		lockedHash:     lockedHash,
 		mu:             new(sync.RWMutex),
 		pendingRequest: pendingRequest,
+		hasBadProposal: hasBadProposal,
 	}
 }
 
@@ -52,7 +53,8 @@ type roundState struct {
 	lockedHash     common.Hash
 	pendingRequest *istanbul.Request
 
-	mu *sync.RWMutex
+	mu             *sync.RWMutex
+	hasBadProposal func(hash common.Hash) bool
 }
 
 func (s *roundState) GetPrepareOrCommitSize() int {
@@ -153,7 +155,10 @@ func (s *roundState) IsHashLocked() bool {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
-	return s.lockedHash != common.Hash{}
+	if common.EmptyHash(s.lockedHash) {
+		return false
+	}
+	return !s.hasBadProposal(s.GetLockedHash())
 }
 
 func (s *roundState) GetLockedHash() common.Hash {
diff --git a/consensus/istanbul/core/roundstate_test.go b/consensus/istanbul/core/roundstate_test.go
@@ -33,6 +33,9 @@ func newTestRoundState(view *istanbul.View, validatorSet istanbul.ValidatorSet)
 		Prepares:   newMessageSet(validatorSet),
 		Commits:    newMessageSet(validatorSet),
 		mu:         new(sync.RWMutex),
+		hasBadProposal: func(hash common.Hash) bool {
+			return false
+		},
 	}
 }
 
diff --git a/consensus/istanbul/core/testbackend_test.go b/consensus/istanbul/core/testbackend_test.go
@@ -131,6 +131,10 @@ func (self *testSystemBackend) NewRequest(request istanbul.Proposal) {
 	})
 }
 
+func (self *testSystemBackend) HasBadProposal(hash common.Hash) bool {
+	return false
+}
+
 func (self *testSystemBackend) LastProposal() (istanbul.Proposal, common.Address) {
 	l := len(self.committedMsgs)
 	if l > 0 {
@@ -205,7 +209,9 @@ func NewTestSystemWithBackend(n, f uint64) *testSystem {
 		core.current = newRoundState(&istanbul.View{
 			Round:    big.NewInt(0),
 			Sequence: big.NewInt(1),
-		}, vset, common.Hash{}, nil, nil)
+		}, vset, common.Hash{}, nil, nil, func(hash common.Hash) bool {
+			return false
+		})
 		core.valSet = vset
 		core.logger = testLogger
 		core.validateFn = backend.CheckValidatorSignature
diff --git a/core/blockchain.go b/core/blockchain.go
@@ -1266,6 +1266,11 @@ func (bc *BlockChain) BadBlocks() ([]BadBlockArgs, error) {
 	return headers, nil
 }
 
+// HasBadBlock returns whether the block with the hash is a bad block
+func (bc *BlockChain) HasBadBlock(hash common.Hash) bool {
+	return bc.badBlocks.Contains(hash)
+}
+
 // addBadBlock adds a bad block to the bad-block LRU cache
 func (bc *BlockChain) addBadBlock(block *types.Block) {
 	bc.badBlocks.Add(block.Header().Hash(), block.Header())
diff --git a/miner/worker.go b/miner/worker.go
@@ -211,7 +211,7 @@ func (self *worker) start() {
 	atomic.StoreInt32(&self.mining, 1)
 
 	if istanbul, ok := self.engine.(consensus.Istanbul); ok {
-		istanbul.Start(self.chain, self.chain.CurrentBlock)
+		istanbul.Start(self.chain, self.chain.CurrentBlock, self.chain.HasBadBlock)
 	}
 
 	// spin up agents

Original file line number	Diff line number	Diff line change
`@@ -67,4 +67,7 @@ type Backend interface {`
`67`	`67`
`68`	`68`	`// ParentValidators returns the validator set of the given proposal's parent block`
`69`	`69`	`ParentValidators(proposal Proposal) ValidatorSet`
	`70`	`+`
	`71`	`+ // HasBadBlock returns whether the block with the hash is a bad block`
	`72`	`+ HasBadProposal(hash common.Hash) bool`
`70`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ func newBlockChain(n int) (core.BlockChain, backend) {`
`51`	`51`	`if err != nil {`
`52`	`52`	`panic(err)`
`53`	`53`	`}`
`54`		`- b.Start(blockchain, blockchain.CurrentBlock)`
	`54`	`+ b.Start(blockchain, blockchain.CurrentBlock, blockchain.HasBadBlock)`
`55`	`55`	`snap, err := b.snapshot(blockchain, 0, common.Hash{}, nil)`
`56`	`56`	`if err != nil {`
`57`	`57`	`panic(err)`
Original file line number	Diff line number	Diff line change
`@@ -276,12 +276,12 @@ func (c core) updateRoundState(view istanbul.View, validatorSet istanbul.Valid`
`276`	`276`	`// Lock only if both roundChange is true and it is locked`
`277`	`277`	`if roundChange && c.current != nil {`
`278`	`278`	`if c.current.IsHashLocked() {`
`279`		`- c.current = newRoundState(view, validatorSet, c.current.GetLockedHash(), c.current.Preprepare, c.current.pendingRequest)`
	`279`	`+ c.current = newRoundState(view, validatorSet, c.current.GetLockedHash(), c.current.Preprepare, c.current.pendingRequest, c.backend.HasBadProposal)`
`280`	`280`	`} else {`
`281`		`- c.current = newRoundState(view, validatorSet, common.Hash{}, nil, c.current.pendingRequest)`
	`281`	`+ c.current = newRoundState(view, validatorSet, common.Hash{}, nil, c.current.pendingRequest, c.backend.HasBadProposal)`
`282`	`282`	`}`
`283`	`283`	`} else {`
`284`		`- c.current = newRoundState(view, validatorSet, common.Hash{}, nil, nil)`
	`284`	`+ c.current = newRoundState(view, validatorSet, common.Hash{}, nil, nil, c.backend.HasBadProposal)`
`285`	`285`	`}`
`286`	`286`	`}`
`287`	`287`