Fix `protoutil.ComputeBlockDataHash` calculation

[tock-ibm]

The method protoutil.ComputeBlockDataHash from Fabric has a known bug. It calculates the hash on a concatenation of the TXs bytes, which is not crypto safe. A different set of TXs with different boundaries between the concatenated bytes would yield the same hash.

The solution is to break and calculate the hash like fabric-x-orderer calculates the batch digest:
github.com/hyperledger/fabric-x-orderer/common/types/batched_requests.go:L92

i.e.

// Digest calculates a sha256 digest on a safe representation of the BatchedRequests.
// This is equivalent to BatchRequestsDataHashWithSerialize, yet faster, and consumes less extra memory.
func (br *BatchedRequests) Digest() []byte {
	if br == nil {
		return sha256.New().Sum(nil)
	}

	sizeBuff := make([]byte, 4)
	h := sha256.New()
	for _, r := range *br {
		binary.BigEndian.PutUint32(sizeBuff, uint32(len(r)))
		h.Write(sizeBuff)
		h.Write(r)
	}

	return h.Sum(nil)
}

[cendhu]

Given that the block data hash is computed by the orderer, the util code should stay within fabric-x-common, and both the committer and the orderer should import it. @liran-funaro FYI

[liran-funaro]

@tock-ibm OK. Let's update the protoutil.ComputeBlockDataHash implementation to be correct.
The same goes for the way we sign blocks.
In Fabric, we concatenated the metadata, header, and data bytes and signed the concatenated array.
This is open to the same attack.
We should amend it as well.

[HagarMeir]

@liran-funaro yes we could do that, although it is a concatenation of different structs so I am not sure the same logic applies

// AsBytes returns the message to sign
func (sig *Signature) AsBytes() []byte {
	msg2Sign := util.ConcatenateBytes(sig.OrdererBlockMetadata, sig.IdentifierHeader, sig.BlockHeader)
	return msg2Sign
}