-
Notifications
You must be signed in to change notification settings - Fork 201
/
interface.go
225 lines (211 loc) · 9.36 KB
/
interface.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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
package crypto
import (
"crypto/cipher"
)
// A Scalar represents a scalar value by which
// a Point (group element) may be encrypted to produce another Point.
// adapted from kyber
type Scalar interface {
// MarshalBinary transforms the Scalar into a byte array
MarshalBinary() ([]byte, error)
// UnmarshalBinary recreates the Scalar from a byte array
UnmarshalBinary([]byte) error
// Equal tests if receiver is equal with the scalar s given as parameter.
// Both scalars need to be derived from the same Group
Equal(s Scalar) (bool, error)
// Set sets the receiver to Scalar s given as parameter
Set(s Scalar) error
// Clone creates a new Scalar with same value as receiver
Clone() Scalar
// SetInt64 sets the receiver to a small integer value v given as parameter
SetInt64(v int64)
// Zero returns the the additive identity (0)
Zero() Scalar
// Add returns the modular sum of receiver with scalar s given as parameter
Add(s Scalar) (Scalar, error)
// Sub returns the modular difference between receiver and scalar s given as parameter
Sub(s Scalar) (Scalar, error)
// Neg returns the modular negation of receiver
Neg() Scalar
// One returns the multiplicative identity (1)
One() Scalar
// Mul returns the modular product of receiver with scalar s given as parameter
Mul(s Scalar) (Scalar, error)
// Div returns the modular division between receiver and scalar s given as parameter
Div(s Scalar) (Scalar, error)
// Inv returns the modular inverse of scalar s given as parameter
Inv(s Scalar) (Scalar, error)
// Pick returns a fresh random or pseudo-random scalar
Pick(rand cipher.Stream) (Scalar, error)
// SetBytes sets the scalar from a byte-slice,
// reducing if necessary to the appropriate modulus.
SetBytes([]byte) (Scalar, error)
// GetUnderlyingObj returns the object the implementation wraps
GetUnderlyingObj() interface{}
// IsInterfaceNil returns true if there is no value under the interface
IsInterfaceNil() bool
}
// Point represents an element of a public-key cryptographic Group.
// adapted from kyber
type Point interface {
// MarshalBinary transforms the Point into a byte array
MarshalBinary() ([]byte, error)
// UnmarshalBinary recreates the Point from a byte array
UnmarshalBinary([]byte) error
// Equal tests if receiver is equal with the Point p given as parameter.
// Both Points need to be derived from the same Group
Equal(p Point) (bool, error)
// Null returns the neutral identity element.
Null() Point
// Base returns the Group's base point.
Base() Point
// Set sets the receiver equal to another Point p.
Set(p Point) error
// Clone returns a clone of the receiver.
Clone() Point
// Add returns the result of adding receiver with Point p given as parameter,
// so that their scalars add homomorphically
Add(p Point) (Point, error)
// Sub returns the result of subtracting from receiver the Point p given as parameter,
// so that their scalars subtract homomorphically
Sub(p Point) (Point, error)
// Neg returns the negation of receiver
Neg() Point
// Mul returns the result of multiplying receiver by the scalar s.
Mul(s Scalar) (Point, error)
// Pick returns a fresh random or pseudo-random Point.
Pick(rand cipher.Stream) (Point, error)
// GetUnderlyingObj returns the object the implementation wraps
GetUnderlyingObj() interface{}
// IsInterfaceNil returns true if there is no value under the interface
IsInterfaceNil() bool
}
// Group defines a mathematical group used for Diffie-Hellmann operations
// adapted from kyber
type Group interface {
// String returns the string for the group
String() string
// ScalarLen returns the maximum length of scalars in bytes
ScalarLen() int
// CreateScalar creates a new Scalar
CreateScalar() Scalar
// PointLen returns the max length of point in nb of bytes
PointLen() int
// CreatePoint creates a new point
CreatePoint() Point
// IsInterfaceNil returns true if there is no value under the interface
IsInterfaceNil() bool
}
// Random is an interface that can be mixed in to local suite definitions.
// adapted from kyber
type Random interface {
// RandomStream returns a cipher.Stream that produces a
// cryptographically random key stream. The stream must
// tolerate being used in multiple goroutines.
RandomStream() cipher.Stream
}
// Suite represents the list of functionalities needed by this package.
// adapted from kyber
type Suite interface {
Group
Random
// CreateKeyPair creates a scalar and a point pair that can be used in asymmetric cryptography
CreateKeyPair(cipher.Stream) (Scalar, Point)
// GetUnderlyingSuite returns the library suite that crypto.Suite wraps
GetUnderlyingSuite() interface{}
}
// KeyGenerator is an interface for generating different types of cryptographic keys
type KeyGenerator interface {
// GeneratePair creates a (crypto.PrivateKey, crypto.PublicKey) pair to be used for asymmetric cryptography
GeneratePair() (PrivateKey, PublicKey)
// PrivateKeyFromByteArray creates a crypto.PrivateKey from a byte array
PrivateKeyFromByteArray(b []byte) (PrivateKey, error)
// PublicKeyFromByteArray creates a crypto.PublicKey from a byte array
PublicKeyFromByteArray(b []byte) (PublicKey, error)
// Suite returns the crypto.Suite used by the KeyGenerator
Suite() Suite
// IsInterfaceNil returns true if there is no value under the interface
IsInterfaceNil() bool
}
// Key represents a crypto key - can be either private or public
type Key interface {
// ToByteArray returns the byte array representation of the key
ToByteArray() ([]byte, error)
// Suite returns the suite used by this key
Suite() Suite
// IsInterfaceNil returns true if there is no value under the interface
IsInterfaceNil() bool
}
// PrivateKey represents a private key that can sign data or decrypt messages encrypted with a public key
type PrivateKey interface {
Key
// GeneratePublic builds a public key for the current private key
GeneratePublic() PublicKey
// Scalar returns the Scalar corresponding to this Private Key
Scalar() Scalar
}
// PublicKey can be used to encrypt messages
type PublicKey interface {
Key
// Point returns the Point corresponding to this Public Key
Point() Point
}
// SingleSigner provides functionality for signing a message and verifying a single signed message
type SingleSigner interface {
// Sign is used to sign a message
Sign(private PrivateKey, msg []byte) ([]byte, error)
// Verify is used to verify a signed message
Verify(public PublicKey, msg []byte, sig []byte) error
// IsInterfaceNil returns true if there is no value under the interface
IsInterfaceNil() bool
}
// MultiSigner provides functionality for multi-signing a message and verifying a multi-signed message
type MultiSigner interface {
// MultiSigVerifier Provides functionality for verifying a multi-signature
MultiSigVerifier
// Reset resets the data holder inside the multiSigner
Reset(pubKeys []string, index uint16) error
// CreateSignatureShare creates a partial signature
CreateSignatureShare(msg []byte, bitmap []byte) ([]byte, error)
// StoreSignatureShare adds the partial signature of the signer with specified position
StoreSignatureShare(index uint16, sig []byte) error
// SignatureShare returns the partial signature set for given index
SignatureShare(index uint16) ([]byte, error)
// VerifySignatureShare verifies the partial signature of the signer with specified position
VerifySignatureShare(index uint16, sig []byte, msg []byte, bitmap []byte) error
// AggregateSigs aggregates all collected partial signatures
AggregateSigs(bitmap []byte) ([]byte, error)
}
// MultiSigVerifier provides functionality for verifying a multi-signature
type MultiSigVerifier interface {
// Create resets the multisigner and initializes to the new params
Create(pubKeys []string, index uint16) (MultiSigner, error)
// SetAggregatedSig sets the aggregated signature
SetAggregatedSig([]byte) error
// Verify verifies the aggregated signature
Verify(msg []byte, bitmap []byte) error
// IsInterfaceNil returns true if there is no value under the interface
IsInterfaceNil() bool
}
// LowLevelSignerBLS provides functionality to sign and verify BLS single/multi-signatures
// Implementations act as a wrapper over a specific crypto library, such that changing the library requires only
// writing a new implementation of this LowLevelSigner
type LowLevelSignerBLS interface {
// VerifySigShare verifies a BLS single signature
VerifySigShare(pubKey PublicKey, message []byte, sig []byte) error
// SignShare creates a BLS single signature over a given message
SignShare(privKey PrivateKey, message []byte) ([]byte, error)
// VerifySigBytes verifies if a byte array represents a BLS signature
VerifySigBytes(suite Suite, sig []byte) error
// AggregateSignatures aggregates BLS single signatures given as byte arrays
AggregateSignatures(suite Suite, sigs ...[]byte) ([]byte, error)
// VerifyAggregatedSig verifies the validity of an aggregated signature over a given message
VerifyAggregatedSig(suite Suite, aggPointsBytes []byte, aggSigBytes []byte, msg []byte) error
// AggregatePublicKeys aggregates a list of public key Points. Returns the byte array representation of the point
AggregatePublicKeys(suite Suite, pubKeys ...Point) ([]byte, error)
// ScalarMulSig provides the result of multiplying a scalar with a signature.
// This is used in the modified BLS multi-signature scheme
ScalarMulSig(suite Suite, scalar Scalar, sig []byte) ([]byte, error)
// IsInterfaceNil returns true if there is no value under the interface
IsInterfaceNil() bool
}