hyperledger/fabric · error

Failing extracting header during channelless check policy wi

Error message

Failing extracting header during channelless check policy with policy [%s]: [%s]

What it means

CheckPolicyNoChannel successfully extracted a Proposal but could not unmarshal proposal.Header into a common.Header protobuf. This means the proposal parsed at the outer layer but its embedded Header field is corrupt or not a serialized Header. The header is required to reach the SignatureHeader and creator identity, so the policy check aborts.

Source

Thrown at core/policy/policy.go:123

// CheckPolicyNoChannel checks that the passed signed proposal is valid with the respect to
// passed policy on the local MSP.
func (p *policyChecker) CheckPolicyNoChannel(policyName string, signedProp *pb.SignedProposal) error {
	if policyName == "" {
		return errors.New("Invalid policy name during channelless check policy. Name must be different from nil.")
	}

	if signedProp == nil {
		return fmt.Errorf("Invalid signed proposal during channelless check policy with policy [%s]", policyName)
	}

	proposal, err := protoutil.UnmarshalProposal(signedProp.ProposalBytes)
	if err != nil {
		return fmt.Errorf("Failing extracting proposal during channelless check policy with policy [%s]: [%s]", policyName, err)
	}

	header, err := protoutil.UnmarshalHeader(proposal.Header)
	if err != nil {
		return fmt.Errorf("Failing extracting header during channelless check policy with policy [%s]: [%s]", policyName, err)
	}

	shdr, err := protoutil.UnmarshalSignatureHeader(header.SignatureHeader)
	if err != nil {
		return fmt.Errorf("Invalid Proposal's SignatureHeader during channelless check policy with policy [%s]: [%s]", policyName, err)
	}

	// Deserialize proposal's creator with the local MSP
	id, err := p.localMSP.DeserializeIdentity(shdr.Creator)
	if err != nil {
		logger.Warnw("Failed deserializing proposal creator during channelless check policy", "error", err, "policyName", policyName, "identity", protoutil.LogMessageForSerializedIdentity(shdr.Creator))
		return fmt.Errorf("Failed deserializing proposal creator during channelless check policy with policy [%s]: [%s]", policyName, err)
	}

	// Load MSPPrincipal for policy
	principal, err := p.principalGetter.Get(policyName)
	if err != nil {
		return fmt.Errorf("Failed getting local MSP principal during channelless check policy with policy [%s]: [%s]", policyName, err)

View on GitHub (pinned to 2736b63f8f)

Solutions

1. Ensure the client sets proposal.Header to protoutil.Marshal(header) of a common.Header (ChannelHeader + SignatureHeader) before signing.
2. Validate on the client that proposal.Header unmarshals back to a common.Header before sending.
3. Rebuild the proposal entirely (don't reuse partially-filled structs) to eliminate stale/corrupted fields.
4. Align protoutil/proto versions between client and peer to rule out wire-format mismatch.

Example fix

// before
proposal := &common.Proposal{Header: headerStruct}

// after
hdrBytes, err := protoutil.Marshal(header)
if err != nil { return err }
proposal := &common.Proposal{Header: hdrBytes}

if len(proposal.Header) == 0 {
    return errors.New("proposal.Header is empty")
}
if _, err := protoutil.UnmarshalHeader(proposal.Header); err != nil {
    return fmt.Errorf("proposal.Header is not a valid common.Header: %w", err)
}

func hasValidHeader(p *common.Proposal) bool {
    if p == nil || len(p.Header) == 0 {
        return false
    }
    _, err := protoutil.UnmarshalHeader(p.Header)
    return err == nil
}

err := policyMgr.CheckPolicy(policyName, signedProp)
if err != nil && strings.Contains(err.Error(), "Failing extracting header") {
    // regenerate the proposal header and re-sign before retrying
}

When it happens

Trigger: A SignedProposal whose Proposal.Bytes decodes as a Proposal but whose Proposal.Header field holds empty, truncated, or wrongly-typed bytes — typically from custom proposal construction or a payload that was overwritten/repacked after signing.

Common situations: Hand-rolled SDK usage that sets Header to nil or to a marshaled SignatureHeader instead of common.Header; test harnesses reusing stale byte slices; schema drift between client and peer protos.

Understand the failure class

Background: "cannot parse invalid wire-format data", "cannot unmarshal", "failed unmarshalling": protobuf unmarshal errors explained — this error's family across 10 libraries.

Related errors

• Failing extracting proposal during channelless check policy
• Invalid Proposal's SignatureHeader during channelless check
• malformed org definition for org: %s
• error encode input
• message of type %s unknown

AI-assisted analysis of hyperledger/fabric@2736b63f8f (2026-09-04). Data as JSON: /api/errors/bbc56a0d6c8a52c0. Report an issue: GitHub.