client

type Client ¶

type Client struct {
}

Client can performs all distributed operations such as: - generating a random distributed secret (rds) - with two rds, it can sign a message

• a self key signing process to be pgp compatible
• a regular signing process to sign any message in a pgp compatible way

func NewClient() *Client

type ClientMessage ¶

type ClientMessage struct {
	Type uint32

	PDkg *PDkg
}

type DKG ¶

type DKG struct {
	sync.Mutex
	// contains filtered or unexported fields
}

func NewDKG(priv *Private, participants []*Identity, r *Router) (*DKG, error)

func (d *DKG) Process(id *Identity, cm *ClientMessage)

func (d *DKG) Run() (*dkg.DistKeyShare, error)

type Dispatcher ¶

type Dispatcher interface {
	RegisterProcessor(Processor)
	Dispatch(*Identity, *ClientMessage)
}

Dispatcher receives messages, decode them and dispatch them to the registered processors. If multiple processors are registered, each message is dispatched to each processors.

type FileFetcher ¶

type FileFetcher interface {
	Accept(url string) bool
	Grab(url string) ([]byte, error)
}

func FindFileFetcher(url string) FileFetcher

func NewHttpFetcher() FileFetcher

type GroupConfig ¶

type GroupConfig struct {
	Name    string
	Email   string
	Comment string

	// coefficients of the public polynomial
	Public []kyber.Point
	// list of node's identity participating
	Ids []Identity
	// threshold of the group
	T int

	PgpID     uint64
	PgpPublic string
}

GroupConfig is the public configuration of a group using mulsigo. It is similar to a public pgp identity with a name, email and comment. It contains the additional public information on all the participants of the group.

type HttpFetcher ¶

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

func (h *HttpFetcher) Accept(url string) bool

func (h *HttpFetcher) Grab(url string) ([]byte, error)

type Identity ¶

type Identity struct {
	Name      string
	Key       []byte
	CreatedAt int64
	Signature []byte
	// reachable - usually empty if using a relay but if provided, will enable
	// one to make direct connection between a pair of peers.
	Address net.Address
}

func (i *Identity) FromToml(f string) error

func (i *Identity) ID() string

func (i *Identity) Point() kyber.Point

func (i *Identity) PublicCurve25519() [32]byte

func (i *Identity) Repr() string

func (i *Identity) Toml() interface{}

type Leader ¶

type Leader struct {
	*Client
}

Leader is a Client that can performs the initial operations such as sending the first message containing the public informations of the pgp key (name, email etc), sending the file/text to sign.

func NewLeader() *Leader

type NonBlockingRouter ¶

type NonBlockingRouter struct {
	Router
}

NonBlockingRouter is a middleware around Router that sends and broadcasts messages in a asynchornous way using goroutine. Each methods returns a channel that will dispatch any future error if any.

func NewNonBlockingRouter(r Router) *NonBlockingRouter

func (n *NonBlockingRouter) Broadcast(cm *ClientMessage, ids ...*Identity) chan error

func (n *NonBlockingRouter) Send(id *Identity, cm *ClientMessage) chan error

type Object ¶

type Object struct {
}

func NewLocalFileObject(path string) (*Object, error)

func NewRemoteFileObject(url string) (*Object, error)

func NewTextObject(text string) *Object

type ObjectHandler ¶

type ObjectHandler interface {
	Accept(*Object) bool
}

ObjectHandler is an interface allowing one to provide custom verification function on any object to be signed. A default impl. is provided which always accept to sign. Another one can be provided that ask to the user on the command line if it's OK or not etc... Implementations can use in conjunctions any FileGrabber implementation if the Object is a RemoteFile object.

type PDkg ¶

type PDkg struct {
	Deal          *dkg.Deal
	Response      *dkg.Response
	Justification *dkg.Justification
}

type Private ¶

type Private struct {
	Public *Identity
	// contains filtered or unexported fields
}

func (p *Private) FromToml(f string) error

func (p *Private) PrivateCurve25519() [32]byte

func (p *Private) PublicCurve25519() [32]byte

func (p *Private) Scalar() kyber.Scalar

func (p *Private) Toml() interface{}

type Processor ¶

type Processor interface {
	Process(*Identity, *ClientMessage)
}

Processor receives a message from a dispatcher.

type ReliablePacket ¶

type ReliablePacket struct {
	Type     ReliableType
	Sequence uint32
	Data     []byte `protobuf:"opt"`
}

type ReliableType ¶

type ReliableType bool

const (
	RELIABLE_DATA ReliableType = true
	RELIABLE_ACK  ReliableType = false
)

type Router ¶

type Router struct {
	// dispatcher used to dispatch message
	Dispatcher

	// global lock making one Send at a time
	// XXX would there be a way to remove that constraint...
	sync.Mutex
	// contains filtered or unexported fields
}

Router is the main "network" entry point enabling one to send messages to a peer and to receive any messages. If it were an interface, it would look like:

type Router interface
   Dispatcher
	Send(*Identity, *ClientMessage) error
	Broadcast(cm *ClientMessage, ids ...*Identity) error
	Close()
}

Originally, the router was an interface but then extracted the only generic behavior to streamFactory.

func NewRouter(factory streamFactory) *Router

func (blr *Router) Broadcast(msg *ClientMessage, ids ...*Identity) error

func (blr *Router) Close()

func (blr *Router) Send(remote *Identity, msg *ClientMessage) error