-
Notifications
You must be signed in to change notification settings - Fork 0
/
registry.go
116 lines (93 loc) · 3.04 KB
/
registry.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
// (c) 2022-2022, LDC Labs, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
package key
import "fmt"
// SignerFactory is a function that returns a Signer for the given key.
type SignerFactory func(Key) (Signer, error)
// VerifierFactory is a function that returns a Verifier for the given key.
type VerifierFactory func(Key) (Verifier, error)
// MACerFactory is a function that returns a MACer for the given key.
type MACerFactory func(Key) (MACer, error)
type keyTriple [3]int
var (
signers = map[keyTriple]SignerFactory{}
verifiers = map[keyTriple]VerifierFactory{}
macers = map[keyTriple]MACerFactory{}
)
// RegisterSigner registers a SignerFactory for the given key type, algorithm, and curve.
// For example, to register a SignerFactory for ed25519 signer:
//
// key.RegisterSigner(key.KtyOKP, key.AlgEdDSA, key.CrvEd25519, ed25519.NewSigner)
func RegisterSigner(kty Kty, alg Alg, crv Crv, fn SignerFactory) {
signers[keyTriple{int(kty), int(alg), int(crv)}] = fn
}
// RegisterVerifier registers a VerifierFactory for the given key type, algorithm, and curve.
func RegisterVerifier(kty Kty, alg Alg, crv Crv, fn VerifierFactory) {
verifiers[keyTriple{int(kty), int(alg), int(crv)}] = fn
}
// RegisterMACer registers a MACerFactory for the given key type, algorithm.
func RegisterMACer(kty Kty, alg Alg, fn MACerFactory) {
macers[keyTriple{int(kty), int(alg), 0}] = fn
}
// Signer returns a Signer for the given key.
// If the key is nil, or SignerFactory for the given key type, algorithm, and curve not registered,
// an error is returned.
func (k Key) Signer() (Signer, error) {
if k == nil {
return nil, fmt.Errorf("nil key")
}
fn, ok := signers[k.tripleKey()]
if !ok {
return nil, fmt.Errorf("signer for %s is not registered", k.tripleName())
}
return fn(k)
}
// Verifier returns a Verifier for the given key.
// If the key is nil, or VerifierFactory for the given key type, algorithm, and curve not registered,
// an error is returned.
func (k Key) Verifier() (Verifier, error) {
if k == nil {
return nil, fmt.Errorf("nil key")
}
fn, ok := verifiers[k.tripleKey()]
if !ok {
return nil, fmt.Errorf("verifier for %s is not registered", k.tripleName())
}
return fn(k)
}
// MACer returns a MACer for the given key.
// If the key is nil, or MACerFactory for the given key type, algorithm not registered,
// an error is returned.
func (k Key) MACer() (MACer, error) {
if k == nil {
return nil, fmt.Errorf("nil key")
}
fn, ok := macers[k.tripleKey()]
if !ok {
return nil, fmt.Errorf("macer for %s is not registered", k.tripleName())
}
return fn(k)
}
func (k Key) tripleKey() keyTriple {
kty := k.Kty()
alg := k.Alg()
crv, _ := k[ParamCrv].(Crv)
if alg == AlgReserved {
switch kty {
case KtyOKP:
alg = AlgEdDSA
crv = CrvEd25519
case KtyEC2:
alg = AlgES256
crv = CrvP256
}
}
return keyTriple{int(kty), int(alg), int(crv)}
}
func (k Key) tripleName() string {
name := k.Kty().String() + "_" + k.Alg().String()
if crv, ok := k[ParamCrv].(Crv); ok {
name += "_" + crv.String()
}
return name
}