cosi

Documentation

Overview

Package cosi defines a collective signing protocol abstraction. A set of participants will work with each others to sign a unique message collectively in the sense that the protocol produces a single signature that will verify the full, or partial, aggregated public key.

Related Papers:

Enhancing Bitcoin Security and Performance with Strong Consistency via Collective Signing (2016) https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_kokoris-kogias.pdf

On the Security of Two-Round Multi-Signatures (2019) https://eprint.iacr.org/2018/417.pdf

Documentation Last Review: 05.10.2020

Index

• func RegisterMessageFormat(name serde.Format, f serde.FormatEngine)
• type Actor
• type CollectiveSigning
• type MessageFactory
  • func NewMessageFactory(msg serde.Factory, sig crypto.SignatureFactory) MessageFactory
  • func (f MessageFactory) Deserialize(ctx serde.Context, data []byte) (serde.Message, error)
• type MsgKey
• type Reactor
• type SigKey
• type SignatureRequest
  • func (req SignatureRequest) Serialize(ctx serde.Context) ([]byte, error)
• type SignatureResponse
  • func (resp SignatureResponse) Serialize(ctx serde.Context) ([]byte, error)
• type Threshold

Functions

func RegisterMessageFormat

func RegisterMessageFormat(name serde.Format, f serde.FormatEngine)

RegisterMessageFormat registers the format for the given format name.

Types

type Actor

type Actor interface {
	// Sign collects the signature of the collective authority and creates an
	// aggregated signature.
	Sign(ctx context.Context, msg serde.Message,
		ca crypto.CollectiveAuthority) (crypto.Signature, error)
}

Actor provides a primitive to sign a message.

type CollectiveSigning

type CollectiveSigning interface {
	// GetSigner returns the individual signer assigned to the instance. One
	// should not use it to verify a collective signature but only for identity
	// verification.
	GetSigner() crypto.Signer

	// GetPublicKeyFactory returns the aggregate public key factory.
	GetPublicKeyFactory() crypto.PublicKeyFactory

	// GetSignatureFactory returns the aggregate signature factory.
	GetSignatureFactory() crypto.SignatureFactory

	// GetVerifierFactory returns a factory that can create a verifier to check
	// the validity of a signature.
	GetVerifierFactory() crypto.VerifierFactory

	// SetThreshold updates the threshold required by a collective signature.
	SetThreshold(Threshold)

	// Listen starts the collective signing so that it will answer to requests.
	Listen(Reactor) (Actor, error)
}

CollectiveSigning is the interface that provides the primitives to sign a message by members of a network.

type MessageFactory

type MessageFactory struct {
	// contains filtered or unexported fields
}

MessageFactory is the message factory for the flat collective signing RPC.

- implements serde.Factory

func NewMessageFactory

func NewMessageFactory(msg serde.Factory, sig crypto.SignatureFactory) MessageFactory

NewMessageFactory returns a new message factory that uses the message and signature factories.

func (MessageFactory) Deserialize

func (f MessageFactory) Deserialize(ctx serde.Context, data []byte) (serde.Message, error)

Deserialize implements serde.Factory.

type MsgKey

type MsgKey struct{}

MsgKey is the key of the message factory.

type Reactor

type Reactor interface {
	serde.Factory

	// Invoke is provided with the message and the address of the sender and it
	// should return the unique hash for this message, or an error for malformed
	// messages.
	Invoke(addr mino.Address, in serde.Message) ([]byte, error)
}

Reactor is a collective signature event handler. Every participant must react to an incoming signature request from the leader, and this abstraction provides the primitive that allows to do so.

type SigKey

type SigKey struct{}

SigKey is the key of the signature factory.

type SignatureRequest

type SignatureRequest struct {
	Value serde.Message
}

SignatureRequest is the message sent to require a signature from the other participants.

- implements serde.Message

func (SignatureRequest) Serialize

func (req SignatureRequest) Serialize(ctx serde.Context) ([]byte, error)

Serialize implements serde.Message. It looks up the format and returns the serialized data if appropriate, otherwise an error.

type SignatureResponse

type SignatureResponse struct {
	Signature crypto.Signature
}

SignatureResponse is the message sent by the participants.

- implements serde.Message

func (SignatureResponse) Serialize

func (resp SignatureResponse) Serialize(ctx serde.Context) ([]byte, error)

Serialize implements serde.Message. It looks up the format and returns the serialized data if appropriate, otherwise an error.

type Threshold

type Threshold func(int) int

Threshold is a function that returns the threshold to reach for a given n, which means it is always positive and below or equal to n.