493 lines
13 KiB
Go
493 lines
13 KiB
Go
package util
|
||
|
||
import (
|
||
"bytes"
|
||
"crypto/sha256"
|
||
pb "schain/proto"
|
||
|
||
"github.com/pkg/errors"
|
||
"google.golang.org/protobuf/proto"
|
||
"google.golang.org/protobuf/types/known/timestamppb"
|
||
)
|
||
|
||
// GetChaincodeActionPayloadFromTransaction 从Transaction中获取ChaincodeActionPayload
|
||
func GetChaincodeActionPayloadFromTransaction(tx *pb.Transaction) (*pb.ChaincodeActionPayload, error) {
|
||
if tx.Payload == nil {
|
||
return nil, errors.New("no ChaincodeActionPayload in Transaction")
|
||
}
|
||
|
||
ccPayload := tx.Payload
|
||
|
||
return ccPayload, nil
|
||
}
|
||
|
||
// GetProposalResponsePayloadFromTransaction 从Transaction中获取ProposalResponsePayload
|
||
func GetProposalResponsePayloadFromTransaction(tx *pb.Transaction) (*pb.ProposalResponsePayload, error) {
|
||
|
||
ccPayload, err := GetChaincodeActionPayloadFromTransaction(tx)
|
||
if err != nil {
|
||
return nil, errors.New("no ChaincodeActionPayload in Transaction")
|
||
}
|
||
|
||
if ccPayload.ProposalResponsePayload == nil {
|
||
return nil, errors.New("no ProposalResponsePayload in ChaincodeActionPayload")
|
||
}
|
||
|
||
prpBytes := ccPayload.ProposalResponsePayload
|
||
prp, err := UnmarshalProposalResponsePayload(prpBytes)
|
||
if err != nil {
|
||
return nil, errors.New("Unmarshal ProposalResponsePayload error")
|
||
}
|
||
|
||
return prp, nil
|
||
}
|
||
|
||
// CreateSignedEnvelope 新建一个附带签名的Envelope
|
||
func CreateSignedEnvelope(
|
||
signer Signer,
|
||
dataMsg proto.Message,
|
||
) (*pb.Envelope, error) {
|
||
var err error
|
||
payloadSignatureHeader := &pb.SignatureHeader{}
|
||
|
||
if signer != nil {
|
||
payloadSignatureHeader, err = NewSignatureHeader(signer)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
data, err := proto.Marshal(dataMsg)
|
||
if err != nil {
|
||
return nil, errors.Wrap(err, "error marshaling")
|
||
}
|
||
|
||
paylBytes := MarshalOrPanic(
|
||
&pb.Payload{
|
||
SignatureHeader: payloadSignatureHeader,
|
||
Data: data,
|
||
},
|
||
)
|
||
|
||
var sig []byte
|
||
if signer != nil {
|
||
sig, err = signer.Sign(paylBytes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
env := &pb.Envelope{
|
||
Payload: paylBytes,
|
||
Signature: sig,
|
||
}
|
||
|
||
return env, nil
|
||
}
|
||
|
||
type Signer interface {
|
||
Sign(msg []byte) ([]byte, error)
|
||
Serialize() ([]byte, error)
|
||
}
|
||
|
||
// CreateSignedTx 创建一笔附带签名的交易
|
||
func CreateSignedTx(
|
||
txID string,
|
||
proposal *pb.Proposal,
|
||
signer Signer,
|
||
resps ...*pb.ProposalResponse,
|
||
) (*pb.Envelope, error) {
|
||
if len(resps) == 0 {
|
||
return nil, errors.New("at least one proposal response is required")
|
||
}
|
||
|
||
if signer == nil {
|
||
return nil, errors.New("signer is required when creating a signed transaction")
|
||
}
|
||
|
||
// the original header
|
||
shdr, err := UnmarshalSignatureHeader(proposal.Header)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// the original payload
|
||
cs, err := UnmarshalChaincodeSpec(proposal.Payload)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// check that the signer is the same that is referenced in the header
|
||
signerBytes, err := signer.Serialize()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if !bytes.Equal(signerBytes, shdr.Creator) {
|
||
return nil, errors.New("signer must be the same as the one referenced in the header")
|
||
}
|
||
|
||
// ensure that all actions are bitwise equal and that they are successful
|
||
var a1 []byte
|
||
for n, r := range resps {
|
||
if r.Response.Status < 200 || r.Response.Status >= 400 {
|
||
return nil, errors.Errorf("proposal response was not successful, error code %d, msg %s", r.Response.Status, r.Response.Message)
|
||
}
|
||
|
||
if n == 0 {
|
||
a1 = r.Payload
|
||
continue
|
||
}
|
||
|
||
if !bytes.Equal(a1, r.Payload) {
|
||
return nil, errors.Errorf("Endorsement results are inconsistent")
|
||
}
|
||
}
|
||
|
||
// fill endorsements according to their uniqueness
|
||
endorsersUsed := make(map[string]struct{})
|
||
var endorsements []*pb.Endorsement
|
||
for _, r := range resps {
|
||
if r.Endorsement == nil {
|
||
continue
|
||
}
|
||
key := string(r.Endorsement.Endorser)
|
||
if _, used := endorsersUsed[key]; used {
|
||
continue
|
||
}
|
||
endorsements = append(endorsements, r.Endorsement)
|
||
endorsersUsed[key] = struct{}{}
|
||
}
|
||
|
||
if len(endorsements) == 0 {
|
||
return nil, errors.Errorf("no endorsements")
|
||
}
|
||
|
||
// create a transaction
|
||
caPayload := &pb.ChaincodeActionPayload{Input: cs, Endorsements: endorsements, ProposalResponsePayload: resps[0].Payload}
|
||
tx := &pb.Transaction{Payload: caPayload}
|
||
|
||
// serialize the tx
|
||
txBytes, err := GetBytesTransaction(tx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// create the payload
|
||
payl := &pb.Payload{SignatureHeader: shdr, Data: txBytes}
|
||
paylBytes, err := GetBytesPayload(payl)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// sign the payload
|
||
sig, err := signer.Sign(paylBytes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// here's the envelope
|
||
return &pb.Envelope{TxID: txID, Payload: paylBytes, Signature: sig}, nil
|
||
}
|
||
|
||
// CreateProposalResponse 新建一个提案回复（ProposalResponse）
|
||
func CreateProposalResponse(
|
||
shdrbytes []byte,
|
||
payload []byte,
|
||
response *pb.Response,
|
||
results []byte,
|
||
signingEndorser Signer,
|
||
) (*pb.ProposalResponse, error) {
|
||
shdr, err := UnmarshalSignatureHeader(shdrbytes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
pHashBytes, err := GetProposalHash(shdr, payload)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error computing proposal hash")
|
||
}
|
||
|
||
// get the bytes of the proposal response payload - we need to sign them
|
||
prpBytes, err := GetBytesProposalResponsePayload(pHashBytes, response, results)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// serialize the signing IDentity
|
||
endorser, err := signingEndorser.Serialize()
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error serializing signing IDentity")
|
||
}
|
||
|
||
// sign the concatenation of the proposal response and the serialized
|
||
// endorser IDentity with this endorser's key
|
||
signature, err := signingEndorser.Sign(append(prpBytes, endorser...))
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "could not sign the proposal response payload")
|
||
}
|
||
|
||
resp := &pb.ProposalResponse{
|
||
Version: 1,
|
||
Timestamp: timestamppb.Now(),
|
||
Endorsement: &pb.Endorsement{
|
||
Signature: signature,
|
||
Endorser: endorser,
|
||
},
|
||
Payload: prpBytes,
|
||
Response: &pb.Response{
|
||
Status: 200,
|
||
Message: "OK",
|
||
},
|
||
}
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// CreateProposalResponseFailure 当背书提案失败或者链码失败时，创建一个 ProposalResponse
|
||
func CreateProposalResponseFailure(
|
||
hdrbytes []byte,
|
||
payl []byte,
|
||
response *pb.Response,
|
||
results []byte,
|
||
) (*pb.ProposalResponse, error) {
|
||
shdr, err := UnmarshalSignatureHeader(hdrbytes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// obtain the proposal hash given proposal header, payload and the requested visibility
|
||
pHashBytes, err := GetProposalHash(shdr, payl)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error computing proposal hash")
|
||
}
|
||
|
||
// get the bytes of the proposal response payload
|
||
prpBytes, err := GetBytesProposalResponsePayload(pHashBytes, response, results)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
resp := &pb.ProposalResponse{
|
||
// Timestamp: TODO!
|
||
Payload: prpBytes,
|
||
Response: response,
|
||
}
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// GetBytesProposalPayloadForTx 从交易中获取ProposalPayload的字节数组
|
||
func GetBytesProposalPayloadForTx(
|
||
payload *pb.ChaincodeSpec,
|
||
) ([]byte, error) {
|
||
// check for nil argument
|
||
if payload == nil {
|
||
return nil, errors.New("nil arguments")
|
||
}
|
||
|
||
// strip the transient bytes off the payload
|
||
cppNoTransient := &pb.ChaincodeSpec{Input: payload.Input}
|
||
cppBytes, err := GetBytesChaincodeSpec(cppNoTransient)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return cppBytes, nil
|
||
}
|
||
|
||
// GetProposalHash 获取Proposal的hash
|
||
func GetProposalHash(signatureHeader *pb.SignatureHeader, ccPropPayl []byte) ([]byte, error) {
|
||
// check for nil argument
|
||
if signatureHeader == nil ||
|
||
ccPropPayl == nil {
|
||
return nil, errors.New("nil arguments")
|
||
}
|
||
|
||
// unmarshal the chaincode proposal payload
|
||
cs, err := UnmarshalChaincodeSpec(ccPropPayl)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
ppBytes, err := GetBytesProposalPayloadForTx(cs)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
signatureHeaderData, err := proto.Marshal(signatureHeader)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
hash2 := sha256.New()
|
||
// hash the serialized Signature Header object
|
||
hash2.Write(signatureHeaderData)
|
||
// hash of the part of the chaincode proposal payload that will go to the tx
|
||
hash2.Write(ppBytes)
|
||
return hash2.Sum(nil), nil
|
||
}
|
||
|
||
// GetSignedProposal 获取SignedProposal
|
||
func GetSignedProposal(proposal *pb.Proposal, signer Signer) (*pb.SignedProposal, error) {
|
||
// check for nil argument
|
||
if proposal == nil {
|
||
return nil, errors.New("proposal cannot be nil")
|
||
}
|
||
|
||
if signer == nil {
|
||
return nil, errors.New("signer cannot be nil")
|
||
}
|
||
|
||
proposalBytes, err := proto.Marshal(proposal)
|
||
if err != nil {
|
||
return nil, errors.Wrap(err, "error marshaling proposal")
|
||
}
|
||
|
||
signature, err := signer.Sign(proposalBytes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &pb.SignedProposal{
|
||
ProposalBytes: proposalBytes,
|
||
Signature: signature,
|
||
}, nil
|
||
}
|
||
|
||
func GetEndorserMsgFromEnvelope(envelop *pb.Envelope) ([]byte, error) {
|
||
tx, err := GetTransactionFromEnvelope(envelop)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting tx from envelop")
|
||
}
|
||
|
||
csBytes, err := GetBytesChaincodeSpec(tx.Payload.Input)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting chaincodeSpecBytes from tx")
|
||
}
|
||
payload, err := UnmarshalPayload(envelop.Payload)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting txPayload from envelop payload")
|
||
}
|
||
pHashBytes, err := GetProposalHash(payload.SignatureHeader, csBytes)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting proposalHash")
|
||
}
|
||
|
||
ca, err := GetChaincodeActionFromEnvelope(envelop)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting chaincodeAction from envelop")
|
||
}
|
||
prpBytes, err := GetBytesProposalResponsePayload(pHashBytes, ca.Response, ca.Results)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting txPayload from envelop")
|
||
}
|
||
return prpBytes, nil
|
||
}
|
||
|
||
func GetPayloadFromEnvelope(envelop *pb.Envelope) (*pb.Payload, error) {
|
||
txPayload, err := UnmarshalPayload(envelop.Payload)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting txPayload from envelop")
|
||
}
|
||
return txPayload, nil
|
||
}
|
||
|
||
func GetTransactionFromEnvelope(envelop *pb.Envelope) (*pb.Transaction, error) {
|
||
txPayload, err := GetPayloadFromEnvelope(envelop)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting txPayload from envelop")
|
||
}
|
||
if txPayload.Data == nil {
|
||
return nil, errors.New("error getting txPayload data: payload data is nil")
|
||
}
|
||
|
||
tx, err := UnmarshalTransaction(txPayload.Data)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting transaction from envelop")
|
||
}
|
||
|
||
return tx, nil
|
||
}
|
||
|
||
func GetProposalResponsePayloadFromEnvelope(envelop *pb.Envelope) (*pb.ProposalResponsePayload, error) {
|
||
tx, err := GetTransactionFromEnvelope(envelop)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting tx from envelop")
|
||
}
|
||
|
||
if tx.Payload == nil {
|
||
return nil, errors.New("error getting tx Payload : tx Payload is nil")
|
||
}
|
||
|
||
proposalResponsePayload, err := UnmarshalProposalResponsePayload(tx.Payload.ProposalResponsePayload)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting proposalResponsePayload from envelop")
|
||
}
|
||
|
||
return proposalResponsePayload, nil
|
||
}
|
||
|
||
func GetChaincodeActionFromEnvelope(envelope *pb.Envelope) (*pb.ChaincodeAction, error) {
|
||
proposalResponsePayload, err := GetProposalResponsePayloadFromEnvelope(envelope)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting proposalResponsePayload from envelop")
|
||
}
|
||
|
||
if proposalResponsePayload.Extension == nil {
|
||
return nil, errors.New("error getting proposalResponsePayload Extension: proposalResponsePayload Extension is nil")
|
||
}
|
||
|
||
ca, err := UnmarshalChaincodeAction(proposalResponsePayload.Extension)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting chaincodeAction from envelop")
|
||
}
|
||
|
||
return ca, nil
|
||
}
|
||
|
||
func GetKVRWSetKwFromEnvelope(envelop *pb.Envelope) (*pb.KVRWSet, error) {
|
||
|
||
ca, err := GetChaincodeActionFromEnvelope(envelop)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting ChaincodeAction from Envelope")
|
||
}
|
||
|
||
kVRWSet, err := UnmarshalKVRWSet(ca.Results)
|
||
if err != nil {
|
||
return nil, errors.WithMessage(err, "error getting kVRWSet ChaincodeAction")
|
||
}
|
||
return kVRWSet, nil
|
||
}
|
||
|
||
func GetOrComputeTxIDFromEnvelope(envelop *pb.Envelope) (string, error) {
|
||
|
||
if envelop.TxID != "" {
|
||
return envelop.TxID, nil
|
||
}
|
||
|
||
txPayload, err := UnmarshalPayload(envelop.Payload)
|
||
if err != nil {
|
||
return "", errors.WithMessage(err, "error getting txID from payload")
|
||
}
|
||
|
||
if txPayload.SignatureHeader == nil {
|
||
return "", errors.New("error getting txID from signatureHeader: payload signatureHeader is nil")
|
||
}
|
||
|
||
sighdr := txPayload.SignatureHeader
|
||
|
||
txID := ComputeTxID(sighdr.Nonce, sighdr.Creator)
|
||
return txID, nil
|
||
}
|
||
|
||
// GetOrComputeTxIDFromEnvelopeBytes 从Envelope中获取交易ID或者计算交易ID
|
||
func GetOrComputeTxIDFromEnvelopeBytes(txEnvelopBytes []byte) (string, error) {
|
||
txEnvelope, err := UnmarshalEnvelope(txEnvelopBytes)
|
||
if err != nil {
|
||
return "", errors.WithMessage(err, "error getting txID from envelope")
|
||
}
|
||
|
||
return GetOrComputeTxIDFromEnvelope(txEnvelope)
|
||
}
|