github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/core/common/ccpackage/ccpackage_test.go (about) 1 /* 2 Copyright hechain. 2022 All Rights Reserved. 3 4 SPDX-License-Identifier: Apache-2.0 5 */ 6 7 package ccpackage 8 9 import ( 10 "fmt" 11 "os" 12 "testing" 13 14 "github.com/golang/protobuf/proto" 15 "github.com/hechain20/hechain/bccsp/sw" 16 "github.com/hechain20/hechain/common/policydsl" 17 "github.com/hechain20/hechain/msp" 18 mspmgmt "github.com/hechain20/hechain/msp/mgmt" 19 msptesttools "github.com/hechain20/hechain/msp/mgmt/testtools" 20 "github.com/hechain20/hechain/protoutil" 21 "github.com/hyperledger/fabric-protos-go/common" 22 mspprotos "github.com/hyperledger/fabric-protos-go/msp" 23 "github.com/hyperledger/fabric-protos-go/peer" 24 ) 25 26 func ownerCreateCCDepSpec(codepackage []byte, sigpolicy *common.SignaturePolicyEnvelope, owner msp.SigningIdentity) (*common.Envelope, error) { 27 cds := &peer.ChaincodeDeploymentSpec{CodePackage: codepackage} 28 return OwnerCreateSignedCCDepSpec(cds, sigpolicy, owner) 29 } 30 31 // create an instantiation policy with just the local msp admin 32 func createInstantiationPolicy(mspid string, role mspprotos.MSPRole_MSPRoleType) *common.SignaturePolicyEnvelope { 33 principals := []*mspprotos.MSPPrincipal{{ 34 PrincipalClassification: mspprotos.MSPPrincipal_ROLE, 35 Principal: protoutil.MarshalOrPanic(&mspprotos.MSPRole{Role: role, MspIdentifier: mspid}), 36 }} 37 sigspolicy := []*common.SignaturePolicy{policydsl.SignedBy(int32(0))} 38 39 // create the policy: it requires exactly 1 signature from any of the principals 40 p := &common.SignaturePolicyEnvelope{ 41 Version: 0, 42 Rule: policydsl.NOutOf(1, sigspolicy), 43 Identities: principals, 44 } 45 46 return p 47 } 48 49 func TestOwnerCreateSignedCCDepSpec(t *testing.T) { 50 mspid, _ := localmsp.GetIdentifier() 51 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 52 env, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, signer) 53 if err != nil || env == nil { 54 t.Fatalf("error owner creating package %s", err) 55 return 56 } 57 } 58 59 func TestAddSignature(t *testing.T) { 60 mspid, _ := localmsp.GetIdentifier() 61 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 62 env, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, signer) 63 if err != nil || env == nil { 64 t.Fatalf("error owner creating package %s", err) 65 return 66 } 67 // add one more with the same signer (we don't have another signer to test with) 68 env, err = SignExistingPackage(env, signer) 69 if err != nil || env == nil { 70 t.Fatalf("error signing existing package %s", err) 71 return 72 } 73 //...and sign aother for luck 74 env, err = SignExistingPackage(env, signer) 75 if err != nil || env == nil { 76 t.Fatalf("error signing existing package %s", err) 77 return 78 } 79 80 p := &common.Payload{} 81 if err = proto.Unmarshal(env.Payload, p); err != nil { 82 t.Fatalf("fatal error unmarshal payload") 83 return 84 } 85 86 sigdepspec := &peer.SignedChaincodeDeploymentSpec{} 87 if err = proto.Unmarshal(p.Data, sigdepspec); err != nil || sigdepspec == nil { 88 t.Fatalf("fatal error unmarshal sigdepspec") 89 return 90 } 91 92 if len(sigdepspec.OwnerEndorsements) != 3 { 93 t.Fatalf("invalid number of endorsements %d", len(sigdepspec.OwnerEndorsements)) 94 return 95 } 96 } 97 98 func TestMissingSigaturePolicy(t *testing.T) { 99 env, err := ownerCreateCCDepSpec([]byte("codepackage"), nil, signer) 100 if err == nil || env != nil { 101 t.Fatalf("expected error on missing signature policy") 102 return 103 } 104 } 105 106 func TestCreateSignedCCDepSpecForInstall(t *testing.T) { 107 mspid, _ := localmsp.GetIdentifier() 108 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 109 env1, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, nil) 110 if err != nil || env1 == nil { 111 t.Fatalf("error owner creating package %s", err) 112 return 113 } 114 115 env2, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, nil) 116 if err != nil || env2 == nil { 117 t.Fatalf("error owner creating package %s", err) 118 return 119 } 120 121 pack := []*common.Envelope{env1, env2} 122 env, err := CreateSignedCCDepSpecForInstall(pack) 123 if err != nil || env == nil { 124 t.Fatalf("error creating install package %s", err) 125 return 126 } 127 128 p := &common.Payload{} 129 if err = proto.Unmarshal(env.Payload, p); err != nil { 130 t.Fatalf("fatal error unmarshal payload") 131 return 132 } 133 134 cip2 := &peer.SignedChaincodeDeploymentSpec{} 135 if err = proto.Unmarshal(p.Data, cip2); err != nil { 136 t.Fatalf("fatal error unmarshal cip") 137 return 138 } 139 140 p = &common.Payload{} 141 if err = proto.Unmarshal(env1.Payload, p); err != nil { 142 t.Fatalf("fatal error unmarshal payload") 143 return 144 } 145 146 cip1 := &peer.SignedChaincodeDeploymentSpec{} 147 if err = proto.Unmarshal(p.Data, cip1); err != nil { 148 t.Fatalf("fatal error unmarshal cip") 149 return 150 } 151 152 if err = ValidateCip(cip1, cip2); err != nil { 153 t.Fatalf("fatal error validating cip1 (%v) against cip2(%v)", cip1, cip2) 154 return 155 } 156 } 157 158 func TestCreateSignedCCDepSpecForInstallWithEndorsements(t *testing.T) { 159 mspid, _ := localmsp.GetIdentifier() 160 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 161 env1, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, signer) 162 if err != nil || env1 == nil { 163 t.Fatalf("error owner creating package %s", err) 164 return 165 } 166 167 env2, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, signer) 168 if err != nil || env2 == nil { 169 t.Fatalf("error owner creating package %s", err) 170 return 171 } 172 173 pack := []*common.Envelope{env1, env2} 174 env, err := CreateSignedCCDepSpecForInstall(pack) 175 if err != nil || env == nil { 176 t.Fatalf("error creating install package %s", err) 177 return 178 } 179 180 p := &common.Payload{} 181 if err = proto.Unmarshal(env.Payload, p); err != nil { 182 t.Fatalf("fatal error unmarshal payload") 183 return 184 } 185 186 cip2 := &peer.SignedChaincodeDeploymentSpec{} 187 if err = proto.Unmarshal(p.Data, cip2); err != nil { 188 t.Fatalf("fatal error unmarshal cip") 189 return 190 } 191 192 if len(cip2.OwnerEndorsements) != 2 { 193 t.Fatalf("invalid number of endorsements %d", len(cip2.OwnerEndorsements)) 194 return 195 } 196 197 p = &common.Payload{} 198 if err = proto.Unmarshal(env1.Payload, p); err != nil { 199 t.Fatalf("fatal error unmarshal payload") 200 return 201 } 202 203 cip1 := &peer.SignedChaincodeDeploymentSpec{} 204 if err = proto.Unmarshal(p.Data, cip1); err != nil { 205 t.Fatalf("fatal error unmarshal cip") 206 return 207 } 208 209 if len(cip1.OwnerEndorsements) != 1 { 210 t.Fatalf("invalid number of endorsements %d", len(cip1.OwnerEndorsements)) 211 return 212 } 213 } 214 215 func TestMismatchedCodePackages(t *testing.T) { 216 mspid, _ := localmsp.GetIdentifier() 217 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 218 env1, err := ownerCreateCCDepSpec([]byte("codepackage1"), sigpolicy, nil) 219 if err != nil || env1 == nil { 220 t.Fatalf("error owner creating package %s", err) 221 return 222 } 223 224 env2, err := ownerCreateCCDepSpec([]byte("codepackage2"), sigpolicy, nil) 225 if err != nil || env2 == nil { 226 t.Fatalf("error owner creating package %s", err) 227 return 228 } 229 pack := []*common.Envelope{env1, env2} 230 env, err := CreateSignedCCDepSpecForInstall(pack) 231 if err == nil || env != nil { 232 t.Fatalf("expected error creating install from mismatched code package but succeeded") 233 return 234 } 235 } 236 237 func TestMismatchedEndorsements(t *testing.T) { 238 mspid, _ := localmsp.GetIdentifier() 239 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 240 env1, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, signer) 241 if err != nil || env1 == nil { 242 t.Fatalf("error owner creating package %s", err) 243 return 244 } 245 246 env2, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, nil) 247 if err != nil || env2 == nil { 248 t.Fatalf("error owner creating package %s", err) 249 return 250 } 251 pack := []*common.Envelope{env1, env2} 252 env, err := CreateSignedCCDepSpecForInstall(pack) 253 if err == nil || env != nil { 254 t.Fatalf("expected error creating install from mismatched endorsed package but succeeded") 255 return 256 } 257 } 258 259 func TestMismatchedSigPolicy(t *testing.T) { 260 sigpolicy1 := createInstantiationPolicy("mspid1", mspprotos.MSPRole_ADMIN) 261 env1, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy1, signer) 262 if err != nil || env1 == nil { 263 t.Fatalf("error owner creating package %s", err) 264 return 265 } 266 267 sigpolicy2 := createInstantiationPolicy("mspid2", mspprotos.MSPRole_ADMIN) 268 env2, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy2, signer) 269 if err != nil || env2 == nil { 270 t.Fatalf("error owner creating package %s", err) 271 return 272 } 273 pack := []*common.Envelope{env1, env2} 274 env, err := CreateSignedCCDepSpecForInstall(pack) 275 if err == nil || env != nil { 276 t.Fatalf("expected error creating install from mismatched signature policies but succeeded") 277 return 278 } 279 } 280 281 var ( 282 localmsp msp.MSP 283 signer msp.SigningIdentity 284 signerSerialized []byte 285 ) 286 287 func TestMain(m *testing.M) { 288 // setup the MSP manager so that we can sign/verify 289 err := msptesttools.LoadMSPSetupForTesting() 290 if err != nil { 291 os.Exit(-1) 292 fmt.Printf("Could not initialize msp") 293 return 294 } 295 296 cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) 297 if err != nil { 298 fmt.Printf("Initialize cryptoProvider bccsp failed: %s", cryptoProvider) 299 os.Exit(-1) 300 return 301 } 302 localmsp = mspmgmt.GetLocalMSP(cryptoProvider) 303 if localmsp == nil { 304 os.Exit(-1) 305 fmt.Printf("Could not get msp") 306 return 307 } 308 signer, err = localmsp.GetDefaultSigningIdentity() 309 if err != nil { 310 os.Exit(-1) 311 fmt.Printf("Could not get signer") 312 return 313 } 314 315 signerSerialized, err = signer.Serialize() 316 if err != nil { 317 os.Exit(-1) 318 fmt.Printf("Could not serialize identity") 319 return 320 } 321 322 os.Exit(m.Run()) 323 }