forked from HyperSpaceChain/obc-peer-1
/
client_ecert_handler.go
98 lines (77 loc) · 3.21 KB
/
client_ecert_handler.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
package crypto
import (
"github.com/openblockchain/obc-peer/openchain/crypto/utils"
obc "github.com/openblockchain/obc-peer/protos"
)
type eCertHandlerImpl struct {
client *clientImpl
}
type eCertTransactionHandlerImpl struct {
client *clientImpl
nonce []byte
binding []byte
}
func (handler *eCertHandlerImpl) init(client *clientImpl) error {
handler.client = client
return nil
}
// GetCertificate returns the TCert DER
func (handler *eCertHandlerImpl) GetCertificate() []byte {
return utils.Clone(handler.client.node.enrollCert.Raw)
}
// Sign signs msg using the signing key corresponding to this TCert
func (handler *eCertHandlerImpl) Sign(msg []byte) ([]byte, error) {
return handler.client.node.signWithEnrollmentKey(msg)
}
// Verify verifies msg using the verifying key corresponding to this TCert
func (handler *eCertHandlerImpl) Verify(signature []byte, msg []byte) error {
ok, err := handler.client.node.verifyWithEnrollmentCert(msg, signature)
if err != nil {
return err
}
if !ok {
return utils.ErrInvalidSignature
}
return nil
}
// GetTransactionHandler returns the transaction handler relative to this certificate
func (handler *eCertHandlerImpl) GetTransactionHandler() (TransactionHandler, error) {
txHandler := &eCertTransactionHandlerImpl{}
err := txHandler.init(handler.client)
if err != nil {
handler.client.node.log.Error("Failed getting transaction handler [%s]", err)
return nil, err
}
return txHandler, nil
}
func (handler *eCertTransactionHandlerImpl) init(client *clientImpl) error {
nonce, err := client.createTransactionNonce()
if err != nil {
client.node.log.Error("Failed initiliazing transaction handler [%s]", err)
return err
}
handler.client = client
handler.nonce = nonce
handler.binding = utils.Hash(append(handler.client.node.enrollCert.Raw, handler.nonce...))
return nil
}
// GetCertificateHandler returns the certificate handler relative to the certificate mapped to this transaction
func (handler *eCertTransactionHandlerImpl) GetCertificateHandler() (CertificateHandler, error) {
return handler.client.GetEnrollmentCertificateHandler()
}
// GetBinding returns an Binding to the underlying transaction layer
func (handler *eCertTransactionHandlerImpl) GetBinding() ([]byte, error) {
return utils.Clone(handler.binding), nil
}
// NewChaincodeDeployTransaction is used to deploy chaincode.
func (handler *eCertTransactionHandlerImpl) NewChaincodeDeployTransaction(chaincodeDeploymentSpec *obc.ChaincodeDeploymentSpec, uuid string) (*obc.Transaction, error) {
return handler.client.newChaincodeDeployUsingECert(chaincodeDeploymentSpec, uuid, handler.nonce)
}
// NewChaincodeExecute is used to execute chaincode's functions.
func (handler *eCertTransactionHandlerImpl) NewChaincodeExecute(chaincodeInvocation *obc.ChaincodeInvocationSpec, uuid string) (*obc.Transaction, error) {
return handler.client.newChaincodeExecuteUsingECert(chaincodeInvocation, uuid, handler.nonce)
}
// NewChaincodeQuery is used to query chaincode's functions.
func (handler *eCertTransactionHandlerImpl) NewChaincodeQuery(chaincodeInvocation *obc.ChaincodeInvocationSpec, uuid string) (*obc.Transaction, error) {
return handler.client.newChaincodeQueryUsingECert(chaincodeInvocation, uuid, handler.nonce)
}