/
deserializer.go
130 lines (109 loc) · 4.11 KB
/
deserializer.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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/*
Copyright IBM Corp. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package fabtoken
import (
"encoding/json"
"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
"github.com/hyperledger-labs/fabric-token-sdk/token/core/identity"
"github.com/hyperledger-labs/fabric-token-sdk/token/core/identity/msp/x509"
"github.com/hyperledger-labs/fabric-token-sdk/token/core/interop/htlc"
"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
"github.com/pkg/errors"
)
// VerifierDES is the interface for verifiers' deserializer
// A verifier checks the validity of a signature against the identity
// associated with the verifier
type VerifierDES interface {
DeserializeVerifier(id view.Identity) (driver.Verifier, error)
}
// Deserializer deserializes verifiers associated with issuers, owners, and auditors
type Deserializer struct {
auditorDeserializer VerifierDES
ownerDeserializer VerifierDES
issuerDeserializer VerifierDES
}
// NewDeserializer returns a deserializer
func NewDeserializer() *Deserializer {
return &Deserializer{
auditorDeserializer: &x509.MSPIdentityDeserializer{},
issuerDeserializer: &x509.MSPIdentityDeserializer{},
ownerDeserializer: htlc.NewDeserializer(identity.NewRawOwnerIdentityDeserializer(&x509.MSPIdentityDeserializer{})),
}
}
// GetOwnerVerifier deserializes the verifier for the passed owner identity
func (d *Deserializer) GetOwnerVerifier(id view.Identity) (driver.Verifier, error) {
return d.ownerDeserializer.DeserializeVerifier(id)
}
// GetIssuerVerifier deserializes the verifier for the passed issuer identity
func (d *Deserializer) GetIssuerVerifier(id view.Identity) (driver.Verifier, error) {
return d.issuerDeserializer.DeserializeVerifier(id)
}
// GetAuditorVerifier deserializes the verifier for the passed auditor identity
func (d *Deserializer) GetAuditorVerifier(id view.Identity) (driver.Verifier, error) {
return d.auditorDeserializer.DeserializeVerifier(id)
}
// GetOwnerMatcher is not needed in fabtoken, as identities are in the clear
func (d *Deserializer) GetOwnerMatcher(raw []byte) (driver.Matcher, error) {
ai := &x509.AuditInfo{}
err := ai.FromBytes(raw)
if err != nil {
return nil, errors.Wrapf(err, "failed to unmarshal")
}
return &x509.AuditInfoDeserializer{CommonName: string(ai.EnrollmentId)}, nil
}
// EnrollmentService returns enrollment IDs behind the owners of token
type EnrollmentService struct {
}
// NewEnrollmentIDDeserializer returns an enrollmentService
func NewEnrollmentIDDeserializer() *EnrollmentService {
return &EnrollmentService{}
}
func (e *EnrollmentService) GetEnrollmentID(auditInfo []byte) (string, error) {
if len(auditInfo) == 0 {
return "", nil
}
// Try to unmarshal it as ScriptInfo
si := &htlc.ScriptInfo{}
err := json.Unmarshal(auditInfo, si)
if err == nil && (len(si.Sender) != 0 || len(si.Recipient) != 0) {
if len(si.Recipient) != 0 {
ai := &x509.AuditInfo{}
if err := ai.FromBytes(si.Recipient); err != nil {
return "", errors.Wrapf(err, "failed unmarshalling audit info [%s]", auditInfo)
}
return ai.EnrollmentId, nil
}
return "", nil
}
ai := &x509.AuditInfo{}
if err := ai.FromBytes(auditInfo); err != nil {
return "", errors.Wrapf(err, "failed unmarshalling audit info [%s]", auditInfo)
}
return ai.EnrollmentId, nil
}
// GetRevocationHandler returns the revocation handler associated with the identity matched to the passed auditInfo
func (e *EnrollmentService) GetRevocationHandler(auditInfo []byte) (string, error) {
if len(auditInfo) == 0 {
return "", nil
}
// Try to unmarshal it as ScriptInfo
si := &htlc.ScriptInfo{}
err := json.Unmarshal(auditInfo, si)
if err == nil && (len(si.Sender) != 0 || len(si.Recipient) != 0) {
if len(si.Recipient) != 0 {
ai := &x509.AuditInfo{}
if err := ai.FromBytes(si.Recipient); err != nil {
return "", errors.Wrapf(err, "failed unamrshalling audit info [%s]", auditInfo)
}
return ai.RevocationHandle, nil
}
return "", nil
}
ai := &x509.AuditInfo{}
if err := ai.FromBytes(auditInfo); err != nil {
return "", errors.Wrapf(err, "failed unmarshalling audit info [%s]", auditInfo)
}
return ai.RevocationHandle, nil
}