[FAB-4327] Don't let peer to crash

Currently peer panics and dies while receiving genesis of the ordering
service, there is no way to recover after such a failure (even after
restarting the peer). This commit takes care to check block type before
trying to create a channel.

Change-Id: Ia72c3e6cccff0632b81f1334fb87841a2aecdab9
Signed-off-by: Artem Barger <[email protected]>

Author: C0rWin

core/scc/cscc/configure.go

@@ -26,6 +26,7 @@ import (
 	"fmt"
 
 	"github.com/golang/protobuf/proto"
+	"github.com/hyperledger/fabric/common/config"
 	"github.com/hyperledger/fabric/common/flogging"
 	"github.com/hyperledger/fabric/common/policies"
 	"github.com/hyperledger/fabric/core/chaincode/shim"
@@ -104,19 +105,33 @@ func (e *PeerConfiger) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
 
 	switch fname {
 	case JoinChain:
+		if args[1] == nil {
+			return shim.Error("Cannot join the channel <nil> configuration block provided")
+		}
+
+		block, err := utils.GetBlockFromBlockBytes(args[1])
+		if err != nil {
+			return shim.Error(fmt.Sprintf("Failed to reconstruct the genesis block, %s", err))
+		}
+
+		cid, err := utils.GetChainIDFromBlock(block)
+		if err != nil {
+			return shim.Error(fmt.Sprintf("\"JoinChain\" request failed to extract "+
+				"channel id from the block due to [%s]", err))
+		}
+
+		if err := validateConfigBlock(block); err != nil {
+			return shim.Error(fmt.Sprintf("\"JoinChain\" for chainID = %s failed because of validation "+
+				"of configuration block, because of %s", cid, err))
+		}
+
 		// 2. check local MSP Admins policy
 		if err = e.policyChecker.CheckPolicyNoChannel(mgmt.Admins, sp); err != nil {
-			cid, e := utils.GetChainIDFromBlockBytes(args[1])
-			errorString := fmt.Sprintf("\"JoinChain\" request failed authorization check "+
-				"for channel [%s]: [%s]", cid, err)
-			if e != nil {
-				errorString = fmt.Sprintf("\"JoinChain\" request failed authorization [%s] and unable "+
-					"to extract channel id from the block due to [%s]", err, e)
-			}
-			return shim.Error(errorString)
+			return shim.Error(fmt.Sprintf("\"JoinChain\" request failed authorization check "+
+				"for channel [%s]: [%s]", cid, err))
 		}
 
-		return joinChain(args[1])
+		return joinChain(cid, block)
 	case GetConfigBlock:
 		// 2. check the channel reader policy
 		if err = e.policyChecker.CheckPolicy(string(args[1]), policies.ChannelApplicationReaders, sp); err != nil {
@@ -135,44 +150,55 @@ func (e *PeerConfiger) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
 	return shim.Error(fmt.Sprintf("Requested function %s not found.", fname))
 }
 
-// joinChain will join the specified chain in the configuration block.
-// Since it is the first block, it is the genesis block containing configuration
-// for this chain, so we want to update the Chain object with this info
-func joinChain(blockBytes []byte) pb.Response {
-	block, err := extractBlock(blockBytes)
+// validateConfigBlock validate configuration block to see whenever it's contains valid config transaction
+func validateConfigBlock(block *common.Block) error {
+	envelopeConfig, err := utils.ExtractEnvelope(block, 0)
 	if err != nil {
-		return shim.Error(fmt.Sprintf("Failed to reconstruct the genesis block, %s", err))
+		return errors.New(fmt.Sprintf("Failed to %s", err))
 	}
 
-	if err = peer.CreateChainFromBlock(block); err != nil {
-		return shim.Error(err.Error())
+	configEnv := &common.ConfigEnvelope{}
+	_, err = utils.UnmarshalEnvelopeOfType(envelopeConfig, common.HeaderType_CONFIG, configEnv)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Bad configuration envelope: %s", err))
 	}
 
-	chainID, err := utils.GetChainIDFromBlock(block)
-	if err != nil {
-		return shim.Error(fmt.Sprintf("Failed to get the chain ID from the configuration block, %s", err))
+	if configEnv.Config == nil {
+		return errors.New("Nil config envelope Config")
 	}
 
-	peer.InitChain(chainID)
+	if configEnv.Config.ChannelGroup == nil {
+		return errors.New("Nil channel group")
+	}
 
-	if err := producer.SendProducerBlockEvent(block); err != nil {
-		cnflogger.Errorf("Error sending block event %s", err)
+	if configEnv.Config.ChannelGroup.Groups == nil {
+		return errors.New("No channel configuration groups are available")
 	}
 
-	return shim.Success(nil)
+	_, exists := configEnv.Config.ChannelGroup.Groups[config.ApplicationGroupKey]
+	if !exists {
+		return errors.New(fmt.Sprintf("Invalid configuration block, missing %s "+
+			"configuration group", config.ApplicationGroupKey))
+	}
+
+	return nil
 }
 
-func extractBlock(bytes []byte) (*common.Block, error) {
-	if bytes == nil {
-		return nil, errors.New("Genesis block must not be nil.")
+// joinChain will join the specified chain in the configuration block.
+// Since it is the first block, it is the genesis block containing configuration
+// for this chain, so we want to update the Chain object with this info
+func joinChain(chainID string, block *common.Block) pb.Response {
+	if err := peer.CreateChainFromBlock(block); err != nil {
+		return shim.Error(err.Error())
 	}
 
-	block, err := utils.GetBlockFromBlockBytes(bytes)
-	if err != nil {
-		return nil, errors.New(fmt.Sprintf("Failed to reconstruct the genesis block, %s", err))
+	peer.InitChain(chainID)
+
+	if err := producer.SendProducerBlockEvent(block); err != nil {
+		cnflogger.Errorf("Error sending block event %s", err)
 	}
 
-	return block, nil
+	return shim.Success(nil)
 }
 
 // Return the current configuration block for the specified chainID. If the

core/scc/cscc/configure_test.go

@@ -24,6 +24,7 @@ import (
 
 	"github.com/golang/protobuf/proto"
 	configtxtest "github.com/hyperledger/fabric/common/configtx/test"
+	"github.com/hyperledger/fabric/common/genesis"
 	"github.com/hyperledger/fabric/common/localmsp"
 	"github.com/hyperledger/fabric/common/mocks/scc"
 	"github.com/hyperledger/fabric/common/policies"
@@ -274,6 +275,33 @@ func TestConfigerInvokeJoinChainCorrectParams(t *testing.T) {
 	}
 }
 
+func TestPeerConfiger_SubmittingOrdererGenesis(t *testing.T) {
+	viper.Set("peer.fileSystemPath", "/tmp/hyperledgertest/")
+	os.Mkdir("/tmp/hyperledgertest", 0755)
+	defer os.RemoveAll("/tmp/hyperledgertest/")
+
+	e := new(PeerConfiger)
+	stub := shim.NewMockStub("PeerConfiger", e)
+
+	if res := stub.MockInit("1", nil); res.Status != shim.OK {
+		fmt.Println("Init failed", string(res.Message))
+		t.FailNow()
+	}
+
+	block, err := genesis.NewFactoryImpl(configtxtest.OrdererTemplate()).Block("testChainID")
+	assert.NoError(t, err)
+	blockBytes := utils.MarshalOrPanic(block)
+
+	// Failed path: wrong parameter type
+	args := [][]byte{[]byte("JoinChain"), []byte(blockBytes)}
+	if res := stub.MockInvoke("2", args); res.Status == shim.OK {
+		t.Fatalf("cscc invoke JoinChain should have failed with wrong genesis block.  args: %v", args)
+	} else {
+		assert.Contains(t, res.Message, "missing Application configuration group")
+	}
+
+}
+
 func mockConfigBlock() []byte {
 	var blockBytes []byte = nil
 	block, err := configtxtest.MakeGenesisBlock("mytestchainid")

protos/utils/commonutils.go

@@ -275,6 +275,10 @@ func IsConfigBlock(block *cb.Block) bool {
 		return false
 	}
 
+	if payload.Header == nil {
+		return false
+	}
+
 	hdr, err := UnmarshalChannelHeader(payload.Header.ChannelHeader)
 	if err != nil {
 		return false