func extractTxID(txEnvelopBytes []byte) (string, error) {
txEnvelope, err := utils.GetEnvelope(txEnvelopBytes)
if err != nil {
return "", err
}
txPayload, err := utils.GetPayload(txEnvelope)
if err != nil {
return "", nil
}
return txPayload.Header.ChainHeader.TxID, nil
}
func extractTransaction(txEnvelopeBytes []byte) (*pb.Transaction, error) {
var err error
var txEnvelope *common.Envelope
var txPayload *common.Payload
var tx *pb.Transaction
if txEnvelope, err = putil.GetEnvelope(txEnvelopeBytes); err != nil {
return nil, err
}
if txPayload, err = putil.GetPayload(txEnvelope); err != nil {
return nil, err
}
if tx, err = putil.GetTransaction(txPayload.Data); err != nil {
return nil, err
}
return tx, nil
}
// ValidateTransaction checks that the transaction envelope is properly formed
func ValidateTransaction(e *common.Envelope) (*common.Payload, []*pb.TransactionAction, error) {
putilsLogger.Infof("ValidateTransactionEnvelope starts for envelope %p", e)
// check for nil argument
if e == nil {
return nil, nil, fmt.Errorf("Nil Envelope")
}
// get the payload from the envelope
payload, err := utils.GetPayload(e)
if err != nil {
return nil, nil, fmt.Errorf("Could not extract payload from envelope, err %s", err)
}
putilsLogger.Infof("Header is %s", payload.Header)
// validate the header
err = validateCommonHeader(payload.Header)
if err != nil {
return nil, nil, err
}
// validate the signature in the envelope
err = checkSignatureFromCreator(payload.Header.SignatureHeader.Creator, e.Signature, e.Payload, payload.Header.ChainHeader.ChainID)
if err != nil {
return nil, nil, err
}
// TODO: ensure that creator can transact with us (some ACLs?) which set of APIs is supposed to give us this info?
// TODO: perform a check against replay attacks
// continue the validation in a way that depends on the type specified in the header
switch common.HeaderType(payload.Header.ChainHeader.Type) {
case common.HeaderType_ENDORSER_TRANSACTION:
rv, err := validateEndorserTransaction(payload.Data, payload.Header)
putilsLogger.Infof("ValidateTransactionEnvelope returns %p, err %s", rv, err)
return payload, rv, err
default:
return nil, nil, fmt.Errorf("Unsupported transaction payload type %d", common.HeaderType(payload.Header.ChainHeader.Type))
}
}
// SendProducerBlockEvent sends block event to clients
func SendProducerBlockEvent(block *common.Block) error {
bevent := &common.Block{}
bevent.Header = block.Header
bevent.Metadata = block.Metadata
bevent.Data = &common.BlockData{}
for _, d := range block.Data.Data {
if d != nil {
if env, err := utils.GetEnvelopeFromBlock(d); err != nil {
logger.Errorf("Error getting tx from block(%s)\n", err)
} else if env != nil {
// get the payload from the envelope
payload, err := utils.GetPayload(env)
if err != nil {
return fmt.Errorf("Could not extract payload from envelope, err %s", err)
}
if common.HeaderType(payload.Header.ChainHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
tx, err := utils.GetTransaction(payload.Data)
if err != nil {
logger.Errorf("Error unmarshalling transaction payload for block event: %s", err)
continue
}
chaincodeActionPayload := &pb.ChaincodeActionPayload{}
err = proto.Unmarshal(tx.Actions[0].Payload, chaincodeActionPayload)
if err != nil {
logger.Errorf("Error unmarshalling transaction action payload for block event: %s", err)
continue
}
propRespPayload := &pb.ProposalResponsePayload{}
err = proto.Unmarshal(chaincodeActionPayload.Action.ProposalResponsePayload, propRespPayload)
if err != nil {
logger.Errorf("Error unmarshalling proposal response payload for block event: %s", err)
continue
}
//ENDORSER_ACTION, ProposalResponsePayload.Extension field contains ChaincodeAction
caPayload := &pb.ChaincodeAction{}
err = proto.Unmarshal(propRespPayload.Extension, caPayload)
if err != nil {
logger.Errorf("Error unmarshalling chaincode action for block event: %s", err)
continue
}
// Drop read write set from transaction before sending block event
caPayload.Results = nil
propRespPayload.Extension, err = proto.Marshal(caPayload)
if err != nil {
logger.Errorf("Error marshalling tx proposal extension payload for block event: %s", err)
continue
}
// Marshal Transaction again and append to block to be sent
chaincodeActionPayload.Action.ProposalResponsePayload, err = proto.Marshal(propRespPayload)
if err != nil {
logger.Errorf("Error marshalling tx proposal payload for block event: %s", err)
continue
}
tx.Actions[0].Payload, err = proto.Marshal(chaincodeActionPayload)
if err != nil {
logger.Errorf("Error marshalling tx action payload for block event: %s", err)
continue
}
if t, err := proto.Marshal(tx); err == nil {
bevent.Data.Data = append(bevent.Data.Data, t)
logger.Infof("calling sendProducerBlockEvent\n")
} else {
logger.Infof("Cannot marshal transaction %s\n", err)
}
}
}
}
}
return Send(CreateBlockEvent(bevent))
}
// Invoke is called to validate the specified block of transactions
// This validation system chaincode will check the read-write set validity and at least 1
// correct endorsement. Later we can create more validation system
// chaincodes to provide more sophisticated policy processing such as enabling
// policy specification to be coded as a transaction of the chaincode and the client
// selecting which policy to use for validation using parameter function
// @return serialized Block of valid and invalid transactions indentified
// Note that Peer calls this function with 2 arguments, where args[0] is the
// function name and args[1] is the Envelope
func (vscc *ValidatorOneValidSignature) Invoke(stub shim.ChaincodeStubInterface) ([]byte, error) {
// args[0] - function name (not used now)
// args[1] - serialized Envelope
args := stub.GetArgs()
if len(args) < 2 {
return nil, errors.New("Incorrect number of arguments")
}
if args[1] == nil {
return nil, errors.New("No block to validate")
}
logger.Infof("VSCC invoked")
// get the envelope...
env, err := utils.GetEnvelope(args[1])
if err != nil {
logger.Errorf("VSCC error: GetEnvelope failed, err %s", err)
return nil, err
}
// ...and the payload...
payl, err := utils.GetPayload(env)
if err != nil {
logger.Errorf("VSCC error: GetPayload failed, err %s", err)
return nil, err
}
// validate the payload type
if common.HeaderType(payl.Header.ChainHeader.Type) != common.HeaderType_ENDORSER_TRANSACTION {
logger.Errorf("Only Endorser Transactions are supported, provided type %d", payl.Header.ChainHeader.Type)
return nil, fmt.Errorf("Only Endorser Transactions are supported, provided type %d", payl.Header.ChainHeader.Type)
}
// ...and the transaction...
tx, err := utils.GetTransaction(payl.Data)
if err != nil {
logger.Errorf("VSCC error: GetTransaction failed, err %s", err)
return nil, err
}
// loop through each of the actions within
for _, act := range tx.Actions {
cap, err := utils.GetChaincodeActionPayload(act.Payload)
if err != nil {
logger.Errorf("VSCC error: GetChaincodeActionPayload failed, err %s", err)
return nil, err
}
// this is what is being signed
prespBytes := cap.Action.ProposalResponsePayload
// loop through each of the endorsements
for _, endorsement := range cap.Action.Endorsements {
// extract the identity of the signer
end, err := mspmgmt.GetManagerForChain(payl.Header.ChainHeader.ChainID).DeserializeIdentity(endorsement.Endorser)
if err != nil {
logger.Errorf("VSCC error: DeserializeIdentity failed, err %s", err)
return nil, err
}
// validate it
err = end.Validate()
if err != nil {
return nil, fmt.Errorf("Invalid endorser identity, err %s", err)
}
// verify the signature
err = end.Verify(append(prespBytes, endorsement.Endorser...), endorsement.Signature)
if err != nil {
return nil, fmt.Errorf("Invalid signature, err %s", err)
}
}
}
logger.Infof("VSCC exists successfully")
return nil, nil
}