github.com/darrenli6/fabric-sdk-example@v0.0.0-20220109053535-94b13b56df8c/peer/gossip/mocks/mocks.go (about)

     1  /*
     2  Copyright IBM Corp. 2017 All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8  		 http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package mocks
    18  
    19  import (
    20  	"bytes"
    21  
    22  	"fmt"
    23  
    24  	"errors"
    25  
    26  	mockpolicies "github.com/hyperledger/fabric/common/mocks/policies"
    27  	"github.com/hyperledger/fabric/common/policies"
    28  	"github.com/hyperledger/fabric/msp"
    29  	"github.com/hyperledger/fabric/protos/common"
    30  	mspproto "github.com/hyperledger/fabric/protos/msp"
    31  )
    32  
    33  type ChannelPolicyManagerGetter struct{}
    34  
    35  func (c *ChannelPolicyManagerGetter) Manager(channelID string) (policies.Manager, bool) {
    36  	return &mockpolicies.Manager{Policy: &mockpolicies.Policy{Err: nil}}, false
    37  }
    38  
    39  type ChannelPolicyManagerGetterWithManager struct {
    40  	Managers map[string]policies.Manager
    41  }
    42  
    43  func (c *ChannelPolicyManagerGetterWithManager) Manager(channelID string) (policies.Manager, bool) {
    44  	return c.Managers[channelID], true
    45  }
    46  
    47  type ChannelPolicyManager struct {
    48  	Policy policies.Policy
    49  }
    50  
    51  func (m *ChannelPolicyManager) GetPolicy(id string) (policies.Policy, bool) {
    52  	return m.Policy, true
    53  }
    54  
    55  func (m *ChannelPolicyManager) Manager(path []string) (policies.Manager, bool) {
    56  	panic("Not implemented")
    57  }
    58  
    59  func (m *ChannelPolicyManager) BasePath() string {
    60  	panic("Not implemented")
    61  }
    62  
    63  func (m *ChannelPolicyManager) PolicyNames() []string {
    64  	panic("Not implemented")
    65  }
    66  
    67  type Policy struct {
    68  	Deserializer msp.IdentityDeserializer
    69  }
    70  
    71  // Evaluate takes a set of SignedData and evaluates whether this set of signatures satisfies the policy
    72  func (m *Policy) Evaluate(signatureSet []*common.SignedData) error {
    73  	fmt.Printf("Evaluate [%s], [% x], [% x]\n", string(signatureSet[0].Identity), string(signatureSet[0].Data), string(signatureSet[0].Signature))
    74  	identity, err := m.Deserializer.DeserializeIdentity(signatureSet[0].Identity)
    75  	if err != nil {
    76  		return err
    77  	}
    78  
    79  	return identity.Verify(signatureSet[0].Data, signatureSet[0].Signature)
    80  }
    81  
    82  type DeserializersManager struct {
    83  	LocalDeserializer    msp.IdentityDeserializer
    84  	ChannelDeserializers map[string]msp.IdentityDeserializer
    85  }
    86  
    87  func (m *DeserializersManager) Deserialize(raw []byte) (*mspproto.SerializedIdentity, error) {
    88  	return &mspproto.SerializedIdentity{Mspid: "mock", IdBytes: raw}, nil
    89  }
    90  
    91  func (m *DeserializersManager) GetLocalMSPIdentifier() string {
    92  	return "mock"
    93  }
    94  
    95  func (m *DeserializersManager) GetLocalDeserializer() msp.IdentityDeserializer {
    96  	return m.LocalDeserializer
    97  }
    98  
    99  func (m *DeserializersManager) GetChannelDeserializers() map[string]msp.IdentityDeserializer {
   100  	return m.ChannelDeserializers
   101  }
   102  
   103  type IdentityDeserializer struct {
   104  	Identity []byte
   105  	Msg      []byte
   106  }
   107  
   108  func (d *IdentityDeserializer) DeserializeIdentity(serializedIdentity []byte) (msp.Identity, error) {
   109  	fmt.Printf("id : [%s], [%s]\n", string(serializedIdentity), string(d.Identity))
   110  	if bytes.Equal(d.Identity, serializedIdentity) {
   111  		fmt.Printf("GOT : [%s], [%s]\n", string(serializedIdentity), string(d.Identity))
   112  		return &Identity{Msg: d.Msg}, nil
   113  	}
   114  
   115  	return nil, errors.New("Invalid Identity")
   116  }
   117  
   118  type Identity struct {
   119  	Msg []byte
   120  }
   121  
   122  func (id *Identity) SatisfiesPrincipal(*mspproto.MSPPrincipal) error {
   123  	return nil
   124  }
   125  
   126  func (id *Identity) GetIdentifier() *msp.IdentityIdentifier {
   127  	return &msp.IdentityIdentifier{Mspid: "mock", Id: "mock"}
   128  }
   129  
   130  func (id *Identity) GetMSPIdentifier() string {
   131  	return "mock"
   132  }
   133  
   134  func (id *Identity) Validate() error {
   135  	return nil
   136  }
   137  
   138  func (id *Identity) GetOrganizationalUnits() []*msp.OUIdentifier {
   139  	return nil
   140  }
   141  
   142  func (id *Identity) Verify(msg []byte, sig []byte) error {
   143  	fmt.Printf("VERIFY [% x], [% x], [% x]\n", string(id.Msg), string(msg), string(sig))
   144  	if bytes.Equal(id.Msg, msg) {
   145  		if bytes.Equal(msg, sig) {
   146  			return nil
   147  		}
   148  	}
   149  
   150  	return errors.New("Invalid Signature")
   151  }
   152  
   153  func (id *Identity) Serialize() ([]byte, error) {
   154  	return []byte("cert"), nil
   155  }