-
Notifications
You must be signed in to change notification settings - Fork 1
/
helper.go
156 lines (121 loc) · 3.19 KB
/
helper.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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
package crypto
import (
"crypto/rand"
"encoding/base64"
"errors"
proto "github.com/golang/protobuf/proto"
"hyperledger.abchain.org/protos"
"io"
"math/big"
)
var DefaultRandSrc io.Reader
var CryptoSchemes = map[string]Factory{}
func init() {
DefaultRandSrc = rand.Reader
}
func PublicKeyFromBytes(raw []byte) (Verifier, error) {
pubProto := &protos.PublicKey{}
err := proto.Unmarshal(raw, pubProto)
if err != nil {
return nil, err
}
return PublicKeyFromPBMessage(pubProto)
}
func PublicKeyToBytes(pk Verifier) ([]byte, error) {
return proto.Marshal(pk.PBMessage())
}
func PrivatekeyFromString(privkeyStr string) (Signer, error) {
raw, err := base64.URLEncoding.DecodeString(privkeyStr)
if err != nil {
return nil, err
}
return PrivatekeyFromBytes(raw)
}
func PrivatekeyToString(priv Signer) (string, error) {
raw, err := proto.Marshal(priv.PBMessage())
if err != nil {
return "", err
}
return base64.URLEncoding.EncodeToString(raw), nil
}
func PrivatekeyFromBytes(raw []byte) (Signer, error) {
privProto := &protos.PrivateKey{}
err := proto.Unmarshal(raw, privProto)
if err != nil {
return nil, err
}
return PrivateKeyFromPBMessage(privProto)
}
func PublicKeyFromPBMessage(pubProto *protos.PublicKey) (Verifier, error) {
switch pubProto.Pub.(type) {
case *protos.PublicKey_Ec:
fac, ok := CryptoSchemes[SCHEME_ECDSA]
if !ok {
return nil, errors.New("ECDSA scheme is not available")
}
v := fac.NewVerifier()
if err := v.FromPBMessage(pubProto); err != nil {
return nil, err
}
return v, nil
default:
return nil, errors.New("Unknown public key type")
}
}
func PrivateKeyFromPBMessage(privProto *protos.PrivateKey) (Signer, error) {
switch privProto.Priv.(type) {
case *protos.PrivateKey_Ec:
fac, ok := CryptoSchemes[SCHEME_ECDSA]
if !ok {
return nil, errors.New("ECDSA scheme is not available")
}
v := fac.NewSigner()
if err := v.FromPBMessage(privProto); err != nil {
return nil, err
}
return v, nil
default:
return nil, errors.New("Unknown private key type")
}
}
func PublicKeyFromSignature(sig *protos.Signature) (Verifier, error) {
switch sig.GetData().(type) {
case *protos.Signature_Ec:
fac, ok := CryptoSchemes[SCHEME_ECDSA]
if !ok {
return nil, errors.New("ECDSA scheme is not available")
}
v := fac.NewVerifier()
if err := v.Recover(sig); err != nil {
return nil, err
}
return v, nil
default:
return nil, errors.New("Unknown signature type")
}
}
func PrivateKeySign(s Signer, index *big.Int, hash []byte) (*protos.Signature, error) {
if chs, err := GetChildPrivateKey(s, index); err != nil {
return nil, err
} else {
return chs.Sign(hash)
}
}
func GetChildPrivateKey(s Signer, index *big.Int) (Signer, error) {
if ch, err := s.Child(index); err != nil {
return nil, err
} else if chs, ok := ch.(Signer); !ok {
return nil, errors.New("Assigned a child not qualified as an signer")
} else {
return chs, nil
}
}
func GetChildPublicKey(pk Verifier, index *big.Int) (Verifier, error) {
if ch, err := pk.Child(index); err != nil {
return nil, err
} else if chpk, ok := ch.(Verifier); !ok {
return nil, errors.New("Assigned a child not qualified as an verifier")
} else {
return chpk, nil
}
}