Documentation
¶
Index ¶
- Variables
- func NewKilicInterface() common.Implementation
- type Kilic
- func (k Kilic) Aggregate(sigs []common.Signature) common.Signature
- func (k Kilic) AggregatePublicKeys(pubs [][]byte) (common.PublicKey, error)
- func (k Kilic) AggregateSignatures(sigs []common.Signature) common.Signature
- func (k Kilic) NewAggregateSignature() common.Signature
- func (k Kilic) PublicKeyFromBytes(pubKey []byte) (common.PublicKey, error)
- func (k Kilic) RandKey() (common.SecretKey, error)
- func (k Kilic) SecretKeyFromBytes(privKey []byte) (common.SecretKey, error)
- func (k Kilic) SignatureFromBytes(sig []byte) (common.Signature, error)
- type PublicKey
- type SecretKey
- type Signature
- func (s *Signature) AggregateVerify(pubKeys []common.PublicKey, msgs [][32]byte) bool
- func (s *Signature) Copy() common.Signature
- func (s *Signature) FastAggregateVerify(pubKeys []common.PublicKey, msg [32]byte) bool
- func (s *Signature) Marshal() []byte
- func (s *Signature) Verify(pubKey common.PublicKey, msg []byte) bool
Constants ¶
This section is empty.
Variables ¶
var ( // ErrorSecSize returned when the secrete key size is wrong ErrorSecSize = errors.New("secret key size is wrong") // ErrorSecUnmarshal returned when the secret key is not valid ErrorSecUnmarshal = errors.New("secret key bytes are not on curve") // ErrorPubKeySize returned when the pubkey size is wrong ErrorPubKeySize = errors.New("pub key size is wrong") // ErrorPubKeyUnmarshal returned when the pubkey is not valid ErrorPubKeyUnmarshal = errors.New("could not unmarshal bytes into public key") // ErrorSigSize returned when the signature bytes doesn't match the length ErrorSigSize = errors.New("signature should be 96 bytes") // ErrorSigUnmarshal returned when the pubkey is not valid ErrorSigUnmarshal = errors.New("could not unmarshal bytes into signature") )
Functions ¶
func NewKilicInterface ¶
func NewKilicInterface() common.Implementation
Types ¶
type Kilic ¶
type Kilic struct {
}
func (Kilic) AggregatePublicKeys ¶
func (Kilic) AggregateSignatures ¶
func (Kilic) NewAggregateSignature ¶
func (Kilic) PublicKeyFromBytes ¶
func (Kilic) SecretKeyFromBytes ¶
type PublicKey ¶
type PublicKey struct {
// contains filtered or unexported fields
}
PublicKey used in the BLS signature scheme.
type SecretKey ¶
type SecretKey struct {
// contains filtered or unexported fields
}
SecretKey used in the BLS signature scheme.
func (*SecretKey) Sign ¶
Sign a message using a secret key - in a beacon/validator client.
In IETF draft BLS specification: Sign(SK, message) -> signature: a signing algorithm that generates
a deterministic signature given a secret key SK and a message.
In ETH2.0 specification: def Sign(SK: int, message: Bytes) -> BLSSignature
type Signature ¶
type Signature struct {
// contains filtered or unexported fields
}
Signature used in the BLS signature scheme.
func (*Signature) AggregateVerify ¶
AggregateVerify verifies each public key against its respective message. This is vulnerable to rogue public-key attack. Each user must provide a proof-of-knowledge of the public key.
In IETF draft BLS specification: AggregateVerify((PK_1, message_1), ..., (PK_n, message_n),
signature) -> VALID or INVALID: an aggregate verification algorithm that outputs VALID if signature is a valid aggregated signature for a collection of public keys and messages, and outputs INVALID otherwise.
In ETH2.0 specification: def AggregateVerify(pairs: Sequence[PK: BLSPubkey, message: Bytes], signature: BLSSignature) -> boo
func (*Signature) FastAggregateVerify ¶
FastAggregateVerify verifies all the provided public keys with their aggregated signature.
In IETF draft BLS specification: FastAggregateVerify(PK_1, ..., PK_n, message, signature) -> VALID
or INVALID: a verification algorithm for the aggregate of multiple signatures on the same message. This function is faster than AggregateVerify.
In ETH2.0 specification: def FastAggregateVerify(PKs: Sequence[BLSPubkey], message: Bytes, signature: BLSSignature) -> bool
func (*Signature) Verify ¶
Verify a bls signature given a public key, a message.
In IETF draft BLS specification: Verify(PK, message, signature) -> VALID or INVALID: a verification
algorithm that outputs VALID if signature is a valid signature of message under public key PK, and INVALID otherwise.
In ETH2.0 specification: def Verify(PK: BLSPubkey, message: Bytes, signature: BLSSignature) -> bool
Source Files